diff --git a/src/NumSharp.Core/APIs/np.fromfile.cs b/src/NumSharp.Core/APIs/np.fromfile.cs
index 8567ae161..ec845efaf 100644
--- a/src/NumSharp.Core/APIs/np.fromfile.cs
+++ b/src/NumSharp.Core/APIs/np.fromfile.cs
@@ -35,7 +35,7 @@ public static NDArray fromfile(string file, Type dtype)
                 var bytes = File.ReadAllBytes(file);
                 switch (dtype.GetTypeCode())
                 {
-#if _REGEN
+#if _REGEN1
 	                %foreach supported_dtypes, supported_dtypes_lowercase%
 	                case NPTypeCode.#1: return new NDArray(new ArraySlice<#2>(UnmanagedMemoryBlock<#2>.FromBuffer(bytes, false)));
 	                %
@@ -44,16 +44,10 @@ public static NDArray fromfile(string file, Type dtype)
 #else
 	                case NPTypeCode.Boolean: return new NDArray(new ArraySlice<bool>(UnmanagedMemoryBlock<bool>.FromBuffer(bytes, false)));
 	                case NPTypeCode.Byte: return new NDArray(new ArraySlice<byte>(UnmanagedMemoryBlock<byte>.FromBuffer(bytes, false)));
-	                case NPTypeCode.Int16: return new NDArray(new ArraySlice<short>(UnmanagedMemoryBlock<short>.FromBuffer(bytes, false)));
-	                case NPTypeCode.UInt16: return new NDArray(new ArraySlice<ushort>(UnmanagedMemoryBlock<ushort>.FromBuffer(bytes, false)));
 	                case NPTypeCode.Int32: return new NDArray(new ArraySlice<int>(UnmanagedMemoryBlock<int>.FromBuffer(bytes, false)));
-	                case NPTypeCode.UInt32: return new NDArray(new ArraySlice<uint>(UnmanagedMemoryBlock<uint>.FromBuffer(bytes, false)));
 	                case NPTypeCode.Int64: return new NDArray(new ArraySlice<long>(UnmanagedMemoryBlock<long>.FromBuffer(bytes, false)));
-	                case NPTypeCode.UInt64: return new NDArray(new ArraySlice<ulong>(UnmanagedMemoryBlock<ulong>.FromBuffer(bytes, false)));
-	                case NPTypeCode.Char: return new NDArray(new ArraySlice<char>(UnmanagedMemoryBlock<char>.FromBuffer(bytes, false)));
-	                case NPTypeCode.Double: return new NDArray(new ArraySlice<double>(UnmanagedMemoryBlock<double>.FromBuffer(bytes, false)));
 	                case NPTypeCode.Single: return new NDArray(new ArraySlice<float>(UnmanagedMemoryBlock<float>.FromBuffer(bytes, false)));
-	                case NPTypeCode.Decimal: return new NDArray(new ArraySlice<decimal>(UnmanagedMemoryBlock<decimal>.FromBuffer(bytes, false)));
+	                case NPTypeCode.Double: return new NDArray(new ArraySlice<double>(UnmanagedMemoryBlock<double>.FromBuffer(bytes, false)));
 	                default:
 		                throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Backends/Default/ArrayManipulation/Default.NDArray.cs b/src/NumSharp.Core/Backends/Default/ArrayManipulation/Default.NDArray.cs
index 9d8dbc970..1ecd27fce 100644
--- a/src/NumSharp.Core/Backends/Default/ArrayManipulation/Default.NDArray.cs
+++ b/src/NumSharp.Core/Backends/Default/ArrayManipulation/Default.NDArray.cs
@@ -14,7 +14,7 @@ public override NDArray CreateNDArray(Shape shape, Type dtype = null, Array buff
 
             switch (dtype.GetTypeCode())
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase,supported_dtypes_defaultvals%
 	            case NPTypeCode.#1:
 	            {
@@ -38,63 +38,27 @@ public override NDArray CreateNDArray(Shape shape, Type dtype = null, Array buff
                     break;
 	            }
 
-	            case NPTypeCode.Int16:
-	            {
-                    slice = new ArraySlice<short>(buffer == null ? new UnmanagedMemoryBlock<short>(shape.size, 0) : UnmanagedMemoryBlock<short>.FromArray((short[])buffer));
-                    break;
-	            }
-
-	            case NPTypeCode.UInt16:
-	            {
-                    slice = new ArraySlice<ushort>(buffer == null ? new UnmanagedMemoryBlock<ushort>(shape.size, 0) : UnmanagedMemoryBlock<ushort>.FromArray((ushort[])buffer));
-                    break;
-	            }
-
 	            case NPTypeCode.Int32:
 	            {
                     slice = new ArraySlice<int>(buffer == null ? new UnmanagedMemoryBlock<int>(shape.size, 0) : UnmanagedMemoryBlock<int>.FromArray((int[])buffer));
                     break;
 	            }
 
-	            case NPTypeCode.UInt32:
-	            {
-                    slice = new ArraySlice<uint>(buffer == null ? new UnmanagedMemoryBlock<uint>(shape.size, 0u) : UnmanagedMemoryBlock<uint>.FromArray((uint[])buffer));
-                    break;
-	            }
-
 	            case NPTypeCode.Int64:
 	            {
                     slice = new ArraySlice<long>(buffer == null ? new UnmanagedMemoryBlock<long>(shape.size, 0L) : UnmanagedMemoryBlock<long>.FromArray((long[])buffer));
                     break;
 	            }
 
-	            case NPTypeCode.UInt64:
-	            {
-                    slice = new ArraySlice<ulong>(buffer == null ? new UnmanagedMemoryBlock<ulong>(shape.size, 0UL) : UnmanagedMemoryBlock<ulong>.FromArray((ulong[])buffer));
-                    break;
-	            }
-
-	            case NPTypeCode.Char:
-	            {
-                    slice = new ArraySlice<char>(buffer == null ? new UnmanagedMemoryBlock<char>(shape.size, '\0') : UnmanagedMemoryBlock<char>.FromArray((char[])buffer));
-                    break;
-	            }
-
-	            case NPTypeCode.Double:
-	            {
-                    slice = new ArraySlice<double>(buffer == null ? new UnmanagedMemoryBlock<double>(shape.size, 0d) : UnmanagedMemoryBlock<double>.FromArray((double[])buffer));
-                    break;
-	            }
-
 	            case NPTypeCode.Single:
 	            {
                     slice = new ArraySlice<float>(buffer == null ? new UnmanagedMemoryBlock<float>(shape.size, 0f) : UnmanagedMemoryBlock<float>.FromArray((float[])buffer));
                     break;
 	            }
 
-	            case NPTypeCode.Decimal:
+	            case NPTypeCode.Double:
 	            {
-                    slice = new ArraySlice<decimal>(buffer == null ? new UnmanagedMemoryBlock<decimal>(shape.size, 0m) : UnmanagedMemoryBlock<decimal>.FromArray((decimal[])buffer));
+                    slice = new ArraySlice<double>(buffer == null ? new UnmanagedMemoryBlock<double>(shape.size, 0d) : UnmanagedMemoryBlock<double>.FromArray((double[])buffer));
                     break;
 	            }
 
@@ -114,7 +78,7 @@ public override NDArray CreateNDArray(Shape shape, Type dtype = null, IArraySlic
             if (buffer == null)
                 switch (dtype.GetTypeCode())
                 {
-#if _REGEN
+#if _REGEN1
 	                %foreach supported_dtypes,supported_dtypes_lowercase,supported_dtypes_defaultvals%
 	                case NPTypeCode.#1:
 	                {
@@ -138,63 +102,27 @@ public override NDArray CreateNDArray(Shape shape, Type dtype = null, IArraySlic
                         break;
 	                }
 
-	                case NPTypeCode.Int16:
-	                {
-                        buffer = new ArraySlice<short>(new UnmanagedMemoryBlock<short>(shape.size, 0));
-                        break;
-	                }
-
-	                case NPTypeCode.UInt16:
-	                {
-                        buffer = new ArraySlice<ushort>(new UnmanagedMemoryBlock<ushort>(shape.size, 0));
-                        break;
-	                }
-
 	                case NPTypeCode.Int32:
 	                {
                         buffer = new ArraySlice<int>(new UnmanagedMemoryBlock<int>(shape.size, 0));
                         break;
 	                }
 
-	                case NPTypeCode.UInt32:
-	                {
-                        buffer = new ArraySlice<uint>(new UnmanagedMemoryBlock<uint>(shape.size, 0u));
-                        break;
-	                }
-
 	                case NPTypeCode.Int64:
 	                {
                         buffer = new ArraySlice<long>(new UnmanagedMemoryBlock<long>(shape.size, 0L));
                         break;
 	                }
 
-	                case NPTypeCode.UInt64:
-	                {
-                        buffer = new ArraySlice<ulong>(new UnmanagedMemoryBlock<ulong>(shape.size, 0UL));
-                        break;
-	                }
-
-	                case NPTypeCode.Char:
-	                {
-                        buffer = new ArraySlice<char>(new UnmanagedMemoryBlock<char>(shape.size, '\0'));
-                        break;
-	                }
-
-	                case NPTypeCode.Double:
-	                {
-                        buffer = new ArraySlice<double>(new UnmanagedMemoryBlock<double>(shape.size, 0d));
-                        break;
-	                }
-
 	                case NPTypeCode.Single:
 	                {
                         buffer = new ArraySlice<float>(new UnmanagedMemoryBlock<float>(shape.size, 0f));
                         break;
 	                }
 
-	                case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        buffer = new ArraySlice<decimal>(new UnmanagedMemoryBlock<decimal>(shape.size, 0m));
+                        buffer = new ArraySlice<double>(new UnmanagedMemoryBlock<double>(shape.size, 0d));
                         break;
 	                }
 
diff --git a/src/NumSharp.Core/Backends/Default/Indexing/Default.NonZero.cs b/src/NumSharp.Core/Backends/Default/Indexing/Default.NonZero.cs
index 4f5249111..fcc9a8340 100644
--- a/src/NumSharp.Core/Backends/Default/Indexing/Default.NonZero.cs
+++ b/src/NumSharp.Core/Backends/Default/Indexing/Default.NonZero.cs
@@ -19,7 +19,7 @@ public partial class DefaultEngine
         /// <returns></returns>
         public override NDArray<int>[] NonZero(in NDArray nd)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (nd.typecode)
 		    {
@@ -37,16 +37,10 @@ public override NDArray<int>[] NonZero(in NDArray nd)
 		    {
 			    case NPTypeCode.Boolean: return nonzeros<bool>(nd.MakeGeneric<bool>());
 			    case NPTypeCode.Byte: return nonzeros<byte>(nd.MakeGeneric<byte>());
-			    case NPTypeCode.Int16: return nonzeros<short>(nd.MakeGeneric<short>());
-			    case NPTypeCode.UInt16: return nonzeros<ushort>(nd.MakeGeneric<ushort>());
 			    case NPTypeCode.Int32: return nonzeros<int>(nd.MakeGeneric<int>());
-			    case NPTypeCode.UInt32: return nonzeros<uint>(nd.MakeGeneric<uint>());
 			    case NPTypeCode.Int64: return nonzeros<long>(nd.MakeGeneric<long>());
-			    case NPTypeCode.UInt64: return nonzeros<ulong>(nd.MakeGeneric<ulong>());
-			    case NPTypeCode.Char: return nonzeros<char>(nd.MakeGeneric<char>());
-			    case NPTypeCode.Double: return nonzeros<double>(nd.MakeGeneric<double>());
 			    case NPTypeCode.Single: return nonzeros<float>(nd.MakeGeneric<float>());
-			    case NPTypeCode.Decimal: return nonzeros<decimal>(nd.MakeGeneric<decimal>());
+			    case NPTypeCode.Double: return nonzeros<double>(nd.MakeGeneric<double>());
 			    default:
 				    throw new NotSupportedException();
 		    }
@@ -60,7 +54,7 @@ private static unsafe NDArray<int>[] nonzeros<T>(NDArray<T> x) where T : unmanag
             var nonzeroCoords = new List<int[]>(x.size / 3);
             var size = x.size;
             Debug.Assert(size > 0);
-#if _REGEN
+#if _REGEN1
             #region Compute
             Func<int[], int> getOffset = x.Shape.GetOffset;
             switch (x.typecode) {
@@ -115,34 +109,6 @@ private static unsafe NDArray<int>[] nonzeros<T>(NDArray<T> x) where T : unmanag
 
                     break;
                 }
-                case NPTypeCode.Int16: {
-                    var incr = new NDCoordinatesIncrementor(x.shape);
-                    var coords = incr.Index;
-                    var src = (short*)x.Address;
-                    int offset;
-                    do
-                    {
-                        offset = getOffset(coords);
-                        if (!(src[offset] == default(short)))
-                            nonzeroCoords.Add(coords.CloneArray());
-                    } while (incr.Next() != null);
-
-                    break;
-                }
-                case NPTypeCode.UInt16: {
-                    var incr = new NDCoordinatesIncrementor(x.shape);
-                    var coords = incr.Index;
-                    var src = (ushort*)x.Address;
-                    int offset;
-                    do
-                    {
-                        offset = getOffset(coords);
-                        if (!(src[offset] == default(ushort)))
-                            nonzeroCoords.Add(coords.CloneArray());
-                    } while (incr.Next() != null);
-
-                    break;
-                }
                 case NPTypeCode.Int32: {
                     var incr = new NDCoordinatesIncrementor(x.shape);
                     var coords = incr.Index;
@@ -157,20 +123,6 @@ private static unsafe NDArray<int>[] nonzeros<T>(NDArray<T> x) where T : unmanag
 
                     break;
                 }
-                case NPTypeCode.UInt32: {
-                    var incr = new NDCoordinatesIncrementor(x.shape);
-                    var coords = incr.Index;
-                    var src = (uint*)x.Address;
-                    int offset;
-                    do
-                    {
-                        offset = getOffset(coords);
-                        if (!(src[offset] == default(uint)))
-                            nonzeroCoords.Add(coords.CloneArray());
-                    } while (incr.Next() != null);
-
-                    break;
-                }
                 case NPTypeCode.Int64: {
                     var incr = new NDCoordinatesIncrementor(x.shape);
                     var coords = incr.Index;
@@ -185,48 +137,6 @@ private static unsafe NDArray<int>[] nonzeros<T>(NDArray<T> x) where T : unmanag
 
                     break;
                 }
-                case NPTypeCode.UInt64: {
-                    var incr = new NDCoordinatesIncrementor(x.shape);
-                    var coords = incr.Index;
-                    var src = (ulong*)x.Address;
-                    int offset;
-                    do
-                    {
-                        offset = getOffset(coords);
-                        if (!(src[offset] == default(ulong)))
-                            nonzeroCoords.Add(coords.CloneArray());
-                    } while (incr.Next() != null);
-
-                    break;
-                }
-                case NPTypeCode.Char: {
-                    var incr = new NDCoordinatesIncrementor(x.shape);
-                    var coords = incr.Index;
-                    var src = (char*)x.Address;
-                    int offset;
-                    do
-                    {
-                        offset = getOffset(coords);
-                        if (!(src[offset] == default(char)))
-                            nonzeroCoords.Add(coords.CloneArray());
-                    } while (incr.Next() != null);
-
-                    break;
-                }
-                case NPTypeCode.Double: {
-                    var incr = new NDCoordinatesIncrementor(x.shape);
-                    var coords = incr.Index;
-                    var src = (double*)x.Address;
-                    int offset;
-                    do
-                    {
-                        offset = getOffset(coords);
-                        if (!(src[offset] == default(double)))
-                            nonzeroCoords.Add(coords.CloneArray());
-                    } while (incr.Next() != null);
-
-                    break;
-                }
                 case NPTypeCode.Single: {
                     var incr = new NDCoordinatesIncrementor(x.shape);
                     var coords = incr.Index;
@@ -241,15 +151,15 @@ private static unsafe NDArray<int>[] nonzeros<T>(NDArray<T> x) where T : unmanag
 
                     break;
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Double: {
                     var incr = new NDCoordinatesIncrementor(x.shape);
                     var coords = incr.Index;
-                    var src = (decimal*)x.Address;
+                    var src = (double*)x.Address;
                     int offset;
                     do
                     {
                         offset = getOffset(coords);
-                        if (!(src[offset] == default(decimal)))
+                        if (!(src[offset] == default(double)))
                             nonzeroCoords.Add(coords.CloneArray());
                     } while (incr.Next() != null);
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Boolean.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Boolean.cs
index 5a3259b7b..42dae0756 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Boolean.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Boolean.cs
@@ -28,7 +28,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of bool
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Add"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,6126 +238,24 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt16(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt16(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt16(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt16(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt16(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt32(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt32(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt32(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt64(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt64(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt64(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToChar(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToChar(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToChar(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToChar(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDouble(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToDouble(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToSingle(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToSingle(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDecimal(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt32(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6365,13 +263,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6379,7 +277,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6389,30 +287,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToInt32(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt64(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6420,13 +318,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6434,7 +332,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6444,30 +342,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToInt64(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToSingle(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6475,13 +373,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6489,7 +387,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6499,30 +397,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToSingle(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDouble(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6530,13 +428,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6544,7 +442,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6554,30 +452,48 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToDouble(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6585,13 +501,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6599,7 +515,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6609,30 +525,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6640,13 +556,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6654,7 +570,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6664,30 +580,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6695,13 +611,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6709,7 +625,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6719,30 +635,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6750,13 +666,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6764,7 +680,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6774,7 +690,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -6835,24 +751,24 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6860,13 +776,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6874,7 +790,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6884,7 +800,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -6894,15 +810,15 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Single: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((float*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7018,24 +934,24 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7043,13 +959,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7057,7 +973,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7067,30 +983,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7098,13 +1014,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7112,7 +1028,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7122,30 +1038,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((bool*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray AddBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Byte.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Byte.cs
index 1bfbe91d1..6103b17d0 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Byte.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Byte.cs
@@ -28,7 +28,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of byte
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Add"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((byte*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray AddByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Char.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Char.cs
deleted file mode 100644
index 3da3851cc..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Char.cs
+++ /dev/null
@@ -1,8259 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray AddChar(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of char
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Add"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((char*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("char"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((char*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Decimal.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Decimal.cs
deleted file mode 100644
index e1ad5bc64..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Decimal.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray AddDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray AddDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of decimal
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Add"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((decimal*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("decimal"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((decimal*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Double.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Double.cs
index b0883cd38..4dbd3e1f1 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Double.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Double.cs
@@ -28,7 +28,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of double
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Add"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((double*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray AddDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int16.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int16.cs
deleted file mode 100644
index 9934481ff..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int16.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray AddInt16(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray AddInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of short
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Add"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((short*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("short"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((short*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int32.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int32.cs
index ef76eb4e6..65d145d60 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int32.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int32.cs
@@ -28,7 +28,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of int
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Add"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((int*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray AddInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int64.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int64.cs
index 580dbbd1b..98c7edb72 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int64.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Int64.cs
@@ -34,7 +34,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of long
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Add"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -244,24 +244,24 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -269,13 +269,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -283,7 +283,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -293,30 +293,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -324,13 +324,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -338,7 +338,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -348,30 +348,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -379,13 +379,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -393,7 +393,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -403,30 +403,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -434,13 +434,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -448,7 +448,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -458,30 +458,48 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -489,13 +507,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -503,7 +521,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -513,30 +531,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -544,13 +562,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -558,7 +576,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -568,30 +586,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -599,13 +617,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -613,7 +631,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -623,30 +641,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -654,13 +672,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -668,7 +686,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -678,7 +696,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -739,24 +757,24 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -764,13 +782,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -778,7 +796,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -788,7 +806,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -798,15 +816,15 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -920,116 +938,6 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1087,24 +995,24 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1112,13 +1020,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1126,7 +1034,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1136,6022 +1044,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7159,13 +1075,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7173,7 +1089,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7183,30 +1099,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7214,13 +1130,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7228,7 +1144,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7238,30 +1154,48 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7269,13 +1203,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7283,7 +1217,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7293,30 +1227,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7324,13 +1258,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7338,7 +1272,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7348,30 +1282,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7379,13 +1313,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7393,7 +1327,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7403,30 +1337,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7434,13 +1368,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7448,7 +1382,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7458,7 +1392,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7519,24 +1453,24 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7544,13 +1478,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7558,7 +1492,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7568,7 +1502,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7578,15 +1512,15 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7702,24 +1636,24 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7727,13 +1661,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7741,7 +1675,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7751,30 +1685,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7782,13 +1716,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7796,7 +1730,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7806,30 +1740,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7837,13 +1771,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7851,7 +1785,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7861,30 +1795,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7892,13 +1826,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7906,7 +1840,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7916,30 +1850,48 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((long*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7947,13 +1899,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7961,7 +1913,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7971,30 +1923,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8002,13 +1954,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8016,7 +1968,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8026,30 +1978,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8057,13 +2009,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8071,7 +2023,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8081,30 +2033,30 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8112,13 +2064,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8126,7 +2078,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8136,7 +2088,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8197,24 +2149,24 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8222,13 +2174,13 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8236,7 +2188,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8246,7 +2198,7 @@ public unsafe NDArray AddInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Single.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Single.cs
index 7857e2996..aadfa8afb 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Single.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.Single.cs
@@ -28,7 +28,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of float
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Add"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((float*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray AddSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.UInt16.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.UInt16.cs
deleted file mode 100644
index 6402c4cee..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.UInt16.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray AddUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray AddUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ushort
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Add"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((ushort*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("ushort"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ushort*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.UInt32.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.UInt32.cs
deleted file mode 100644
index af6fcd028..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.UInt32.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray AddUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray AddUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of uint
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Add"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((uint*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("uint"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((uint*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.UInt64.cs b/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.UInt64.cs
deleted file mode 100644
index 909b49333..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Add/Default.Add.UInt64.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray AddUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray AddUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ulong
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Add"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((ulong*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("ulong"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Add(*((ulong*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Add(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Add((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/BLAS/Default.Dot.NDMD.cs b/src/NumSharp.Core/Backends/Default/Math/BLAS/Default.Dot.NDMD.cs
index 01ca763e7..daafe7c56 100644
--- a/src/NumSharp.Core/Backends/Default/Math/BLAS/Default.Dot.NDMD.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/BLAS/Default.Dot.NDMD.cs
@@ -29,7 +29,7 @@ public static NDArray DotNDMD(in NDArray lhs, in NDArray rhs)
             var ret = new NDArray(np._FindCommonArrayType(lhs.typecode, rhs.typecode), retShape);
 
             //TODO! we can optimize GetOffset here
-#if _REGEN
+#if _REGEN1
             %letters = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","aa","bb","cc","dd","ee","ff","gg","hh","ii","jj","kk","ll","mm","nn","oo","pp","qq","rr","ss","tt","uu","vv","ww","xx","yy","zz"]
             switch (lshape.Length) {
             %foreach range(2, 14)%
diff --git a/src/NumSharp.Core/Backends/Default/Math/BLAS/Default.MatMul.2D2D.cs b/src/NumSharp.Core/Backends/Default/Math/BLAS/Default.MatMul.2D2D.cs
index 1c1e41edf..b140a880d 100644
--- a/src/NumSharp.Core/Backends/Default/Math/BLAS/Default.MatMul.2D2D.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/BLAS/Default.MatMul.2D2D.cs
@@ -40,7 +40,7 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
             NDArray result = @out ?? new NDArray(np._FindCommonArrayType(left.GetTypeCode, right.GetTypeCode), Shape.Matrix(rows, othercolumns));
 
-#if _REGEN
+#if _REGEN1
 #region Compute
             switch (result.typecode)
             {
@@ -109,112 +109,107 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        case NPTypeCode.Int32: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
@@ -228,21 +223,21 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
@@ -255,7 +250,7 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                             break;
                         }
-                        case NPTypeCode.Int16: { 
+                        case NPTypeCode.Int64: { 
                             switch (right.typecode)
                             {
                                 case NPTypeCode.Byte: { 
@@ -265,119 +260,114 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        case NPTypeCode.Single: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
@@ -391,21 +381,21 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
@@ -418,7 +408,7 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                             break;
                         }
-                        case NPTypeCode.UInt16: { 
+                        case NPTypeCode.Double: { 
                             switch (right.typecode)
                             {
                                 case NPTypeCode.Byte: { 
@@ -428,120 +418,124 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
                                             byte sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
+                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
                                             result.SetByte(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        default:
+                            throw new NotSupportedException();
+                    }
+                    
+                    break;
+                }
+                case NPTypeCode.Int32: { 
+                    switch (left.typecode)
+                    {
+                        case NPTypeCode.Byte: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
@@ -552,24 +546,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
@@ -589,122 +583,117 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        case NPTypeCode.Int64: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
@@ -715,24 +704,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
@@ -744,7 +733,7 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                             break;
                         }
-                        case NPTypeCode.UInt32: { 
+                        case NPTypeCode.Single: { 
                             switch (right.typecode)
                             {
                                 case NPTypeCode.Byte: { 
@@ -752,17816 +741,38 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetByte(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            byte sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Char: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Double: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Single: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Decimal: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            byte sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (byte)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetByte(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        default:
-                            throw new NotSupportedException();
-                    }
-                    
-                    break;
-                }
-                case NPTypeCode.Int16: { 
-                    switch (left.typecode)
-                    {
-                        case NPTypeCode.Byte: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Char: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Double: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Single: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Decimal: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            short sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (short)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        default:
-                            throw new NotSupportedException();
-                    }
-                    
-                    break;
-                }
-                case NPTypeCode.UInt16: { 
-                    switch (left.typecode)
-                    {
-                        case NPTypeCode.Byte: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Char: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Double: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Single: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Decimal: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ushort sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ushort)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt16(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        default:
-                            throw new NotSupportedException();
-                    }
-                    
-                    break;
-                }
-                case NPTypeCode.Int32: { 
-                    switch (left.typecode)
-                    {
-                        case NPTypeCode.Byte: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Char: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Double: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Single: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Decimal: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            int sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (int)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        default:
-                            throw new NotSupportedException();
-                    }
-                    
-                    break;
-                }
-                case NPTypeCode.UInt32: { 
-                    switch (left.typecode)
-                    {
-                        case NPTypeCode.Byte: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Char: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Double: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Single: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Decimal: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            uint sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (uint)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt32(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        default:
-                            throw new NotSupportedException();
-                    }
-                    
-                    break;
-                }
-                case NPTypeCode.Int64: { 
-                    switch (left.typecode)
-                    {
-                        case NPTypeCode.Byte: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Char: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Double: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Single: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Decimal: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            long sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (long)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        default:
-                            throw new NotSupportedException();
-                    }
-                    
-                    break;
-                }
-                case NPTypeCode.UInt64: { 
-                    switch (left.typecode)
-                    {
-                        case NPTypeCode.Byte: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Char: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Double: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Single: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Decimal: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            ulong sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (ulong)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetUInt64(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        default:
-                            throw new NotSupportedException();
-                    }
-                    
-                    break;
-                }
-                case NPTypeCode.Char: { 
-                    switch (left.typecode)
-                    {
-                        case NPTypeCode.Byte: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Char: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Double: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Single: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Decimal: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            char sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (char)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetChar(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        default:
-                            throw new NotSupportedException();
-                    }
-                    
-                    break;
-                }
-                case NPTypeCode.Double: { 
-                    switch (left.typecode)
-                    {
-                        case NPTypeCode.Byte: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Char: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Double: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Single: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Decimal: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            double sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (double)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetDouble(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        default:
-                            throw new NotSupportedException();
-                    }
-                    
-                    break;
-                }
-                case NPTypeCode.Single: { 
-                    switch (left.typecode)
-                    {
-                        case NPTypeCode.Byte: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt32: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt64: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Char: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Double: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Single: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Decimal: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            float sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (float)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetSingle(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        default:
-                            throw new NotSupportedException();
-                    }
-                    
-                    break;
-                }
-                case NPTypeCode.Decimal: { 
-                    switch (left.typecode)
-                    {
-                        case NPTypeCode.Byte: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetByte(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.Int16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Single: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Decimal: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                default:
-                                    throw new NotSupportedException();
-                            }
-
-                            break;
-                        }
-                        case NPTypeCode.UInt16: { 
-                            switch (right.typecode)
-                            {
-                                case NPTypeCode.Byte: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt16: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt32: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Char: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
-
-                                    break;
-                                }
-                                case NPTypeCode.Double: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
@@ -18572,24 +783,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt16(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
@@ -18601,7 +812,7 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                             break;
                         }
-                        case NPTypeCode.Int32: { 
+                        case NPTypeCode.Double: { 
                             switch (right.typecode)
                             {
                                 case NPTypeCode.Byte: { 
@@ -18609,122 +820,126 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            int sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (int)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
+                                            result.SetInt32(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        default:
+                            throw new NotSupportedException();
+                    }
+                    
+                    break;
+                }
+                case NPTypeCode.Int64: { 
+                    switch (left.typecode)
+                    {
+                        case NPTypeCode.Byte: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
@@ -18735,24 +950,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
@@ -18764,7 +979,7 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                             break;
                         }
-                        case NPTypeCode.UInt32: { 
+                        case NPTypeCode.Int32: { 
                             switch (right.typecode)
                             {
                                 case NPTypeCode.Byte: { 
@@ -18772,122 +987,117 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        case NPTypeCode.Int64: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
@@ -18898,24 +1108,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt32(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
@@ -18927,7 +1137,7 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                             break;
                         }
-                        case NPTypeCode.Int64: { 
+                        case NPTypeCode.Single: { 
                             switch (right.typecode)
                             {
                                 case NPTypeCode.Byte: { 
@@ -18935,122 +1145,117 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        case NPTypeCode.Double: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
@@ -19061,24 +1266,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            long sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (long)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
+                                            result.SetInt64(sum, row, column);
                                         }
                                     }
 
@@ -19090,7 +1295,16 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                             break;
                         }
-                        case NPTypeCode.UInt64: { 
+                        default:
+                            throw new NotSupportedException();
+                    }
+                    
+                    break;
+                }
+                case NPTypeCode.Single: { 
+                    switch (left.typecode)
+                    {
+                        case NPTypeCode.Byte: { 
                             switch (right.typecode)
                             {
                                 case NPTypeCode.Byte: { 
@@ -19098,122 +1312,117 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        case NPTypeCode.Int32: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
@@ -19224,24 +1433,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetUInt64(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
@@ -19253,7 +1462,7 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                             break;
                         }
-                        case NPTypeCode.Char: { 
+                        case NPTypeCode.Int64: { 
                             switch (right.typecode)
                             {
                                 case NPTypeCode.Byte: { 
@@ -19261,122 +1470,117 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        case NPTypeCode.Single: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
@@ -19387,24 +1591,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetChar(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
@@ -19424,122 +1628,126 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            float sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (float)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
+                                            result.SetSingle(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        default:
+                            throw new NotSupportedException();
+                    }
+                    
+                    break;
+                }
+                case NPTypeCode.Double: { 
+                    switch (left.typecode)
+                    {
+                        case NPTypeCode.Byte: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetByte(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetInt32(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetInt64(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
@@ -19550,24 +1758,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetSingle(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDouble(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetByte(row, i), right.GetDouble(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
@@ -19579,7 +1787,7 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                             break;
                         }
-                        case NPTypeCode.Single: { 
+                        case NPTypeCode.Int32: { 
                             switch (right.typecode)
                             {
                                 case NPTypeCode.Byte: { 
@@ -19587,122 +1795,117 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetByte(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetInt32(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetInt64(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetSingle(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetInt32(row, i), right.GetDouble(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        case NPTypeCode.Int64: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetByte(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetInt32(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetInt64(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
@@ -19713,24 +1916,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetSingle(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetSingle(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetInt64(row, i), right.GetDouble(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
@@ -19742,7 +1945,7 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
 
                             break;
                         }
-                        case NPTypeCode.Decimal: { 
+                        case NPTypeCode.Single: { 
                             switch (right.typecode)
                             {
                                 case NPTypeCode.Byte: { 
@@ -19750,122 +1953,117 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetByte(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetByte(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int16: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetInt32(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt16: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt16(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetInt64(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int32: { 
+                                case NPTypeCode.Single: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetSingle(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.UInt32: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt32(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetSingle(row, i), right.GetDouble(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Int64: { 
-                                    for (int row = 0; row < rows; row++)
-                                    {
-                                        for (int column = 0; column < othercolumns; column++)
-                                        {
-                                            decimal sum = default;
-                                            for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
-                                        }
-                                    }
+                                default:
+                                    throw new NotSupportedException();
+                            }
 
-                                    break;
-                                }
-                                case NPTypeCode.UInt64: { 
+                            break;
+                        }
+                        case NPTypeCode.Double: { 
+                            switch (right.typecode)
+                            {
+                                case NPTypeCode.Byte: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetUInt64(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetByte(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Char: { 
+                                case NPTypeCode.Int32: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetChar(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetInt32(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Double: { 
+                                case NPTypeCode.Int64: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetDouble(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetInt64(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
@@ -19876,24 +2074,24 @@ protected static NDArray MultiplyMatrix(NDArray left, NDArray right, NDArray @ou
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetSingle(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetSingle(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
                                     break;
                                 }
-                                case NPTypeCode.Decimal: { 
+                                case NPTypeCode.Double: { 
                                     for (int row = 0; row < rows; row++)
                                     {
                                         for (int column = 0; column < othercolumns; column++)
                                         {
-                                            decimal sum = default;
+                                            double sum = default;
                                             for (int i = 0; i < columns; i++)
-                                                sum += (decimal)(Operator.Multiply(left.GetDecimal(row, i), right.GetDecimal(i, column)));
-                                            result.SetDecimal(sum, row, column);
+                                                sum += (double)(Operator.Multiply(left.GetDouble(row, i), right.GetDouble(i, column)));
+                                            result.SetDouble(sum, row, column);
                                         }
                                     }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.ACos.cs b/src/NumSharp.Core/Backends/Default/Math/Default.ACos.cs
index 85c28bcee..1bef85327 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.ACos.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.ACos.cs
@@ -22,7 +22,7 @@ public override NDArray ACos(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -40,52 +40,28 @@ public override NDArray ACos(in NDArray nd, NPTypeCode? typeCode = null)
 	                default:
 		                throw new NotSupportedException();
 #else
-                    case NPTypeCode.Byte:
+	                case NPTypeCode.Byte:
 	                {
                         var out_addr = (byte*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Acos(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Acos(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Acos(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Acos(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Acos(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Acos(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Acos(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
+	                case NPTypeCode.Single:
 	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Acos(*(out_addr + i))));
+                        var out_addr = (float*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Acos(*(out_addr + i))));
                         return @out;
 	                }
 	                case NPTypeCode.Double:
@@ -94,12 +70,6 @@ public override NDArray ACos(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Acos(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Single:
-	                {
-                        var out_addr = (float*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Acos(*(out_addr + i))));
-                        return @out;
-	                }
                     case NPTypeCode.Decimal:
 	                {
                         var out_addr = (decimal*)@out.Address;
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.ASin.cs b/src/NumSharp.Core/Backends/Default/Math/Default.ASin.cs
index 4ab24164e..144ab9c02 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.ASin.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.ASin.cs
@@ -22,7 +22,7 @@ public override NDArray ASin(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -40,52 +40,28 @@ public override NDArray ASin(in NDArray nd, NPTypeCode? typeCode = null)
 	                default:
 		                throw new NotSupportedException();
 #else
-                    case NPTypeCode.Byte:
+	                case NPTypeCode.Byte:
 	                {
                         var out_addr = (byte*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Asin(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Asin(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Asin(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Asin(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Asin(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Asin(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Asin(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
+	                case NPTypeCode.Single:
 	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Asin(*(out_addr + i))));
+                        var out_addr = (float*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Asin(*(out_addr + i))));
                         return @out;
 	                }
 	                case NPTypeCode.Double:
@@ -94,12 +70,6 @@ public override NDArray ASin(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Asin(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Single:
-	                {
-                        var out_addr = (float*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Asin(*(out_addr + i))));
-                        return @out;
-	                }
                     case NPTypeCode.Decimal:
 	                {
                         var out_addr = (decimal*)@out.Address;
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.ATan.cs b/src/NumSharp.Core/Backends/Default/Math/Default.ATan.cs
index 8efc90ecd..26568eccb 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.ATan.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.ATan.cs
@@ -22,7 +22,7 @@ public override NDArray ATan(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -40,52 +40,28 @@ public override NDArray ATan(in NDArray nd, NPTypeCode? typeCode = null)
 	                default:
 		                throw new NotSupportedException();
 #else
-                    case NPTypeCode.Byte:
+	                case NPTypeCode.Byte:
 	                {
                         var out_addr = (byte*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Atan(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Atan(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Atan(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Atan(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Atan(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Atan(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Atan(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
+	                case NPTypeCode.Single:
 	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Atan(*(out_addr + i))));
+                        var out_addr = (float*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Atan(*(out_addr + i))));
                         return @out;
 	                }
 	                case NPTypeCode.Double:
@@ -94,12 +70,6 @@ public override NDArray ATan(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Atan(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Single:
-	                {
-                        var out_addr = (float*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Atan(*(out_addr + i))));
-                        return @out;
-	                }
                     case NPTypeCode.Decimal:
 	                {
                         var out_addr = (decimal*)@out.Address;
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.ATan2.cs b/src/NumSharp.Core/Backends/Default/Math/Default.ATan2.cs
index 0a1f53279..fa19976d9 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.ATan2.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.ATan2.cs
@@ -22,100 +22,52 @@ public override NDArray ATan2(in NDArray y, in NDArray x, NPTypeCode? typeCode =
             {
                 switch (out_y.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
-                        var out_addr = (#2*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.To#1(Math.Atan2(*(out_addr + i))));
-                        return @out;
+                        var out_addr = (#2*)out_y.Address;
+                        var out_addr_x = (byte*)out_x.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.To#1(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
+                        return out_y;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Tan(*(out_addr + i))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
 	                case NPTypeCode.Byte:
 	                {
                         var out_addr = (byte*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-
-                            Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
-                        return out_y;
-	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-                            Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
-                        return out_y;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-                            Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
+                        var out_addr_x = (byte*)out_x.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
                         return out_y;
 	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-                            Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
-                        return out_y;
-	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-                            Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
+                        var out_addr_x = (byte*)out_x.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
                         return out_y;
 	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-                            Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
-                        return out_y;
-	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-                            Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
-                        return out_y;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-                            Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
-                        return out_y;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-                            Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
+                        var out_addr_x = (byte*)out_x.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
                         return out_y;
 	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-                            Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
+                        var out_addr_x = (byte*)out_x.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
                         return out_y;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)out_y.Address;
-                            var out_addr_x = (byte*)out_x.Address;
-                            Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.ATan2(*(out_addr + i), *(out_addr_x + i))));
+                        var out_addr = (double*)out_y.Address;
+                        var out_addr_x = (byte*)out_x.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Atan2(*(out_addr + i), *(out_addr_x + i))));
                         return out_y;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Abs.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Abs.cs
index 9da89f7fd..a4ae1f324 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Abs.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Abs.cs
@@ -24,7 +24,7 @@ public override NDArray Abs(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -44,16 +44,8 @@ public override NDArray Abs(in NDArray nd, NPTypeCode? typeCode = null)
 #else
 	                case NPTypeCode.Byte:
 	                {
-                        return @out;
-	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Abs(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
+                        var out_addr = (byte*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Abs(*(out_addr + i))));
                         return @out;
 	                }
 	                case NPTypeCode.Int32:
@@ -62,24 +54,16 @@ public override NDArray Abs(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Abs(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Abs(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
+	                case NPTypeCode.Single:
 	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Abs(*(out_addr + i))));
+                        var out_addr = (float*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Abs(*(out_addr + i))));
                         return @out;
 	                }
 	                case NPTypeCode.Double:
@@ -88,12 +72,6 @@ public override NDArray Abs(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Abs(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Single:
-	                {
-                        var out_addr = (float*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Abs(*(out_addr + i))));
-                        return @out;
-	                }
                     case NPTypeCode.Decimal:
 	                {
                         var out_addr = (decimal*)@out.Address;
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Add.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Add.cs
index 3c79396f7..ba1e3498c 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Add.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Add.cs
@@ -8,7 +8,7 @@ public override NDArray Add(in NDArray lhs, in NDArray rhs)
         {
             switch (lhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return Add#1(lhs, rhs);
 	            %
@@ -17,16 +17,10 @@ public override NDArray Add(in NDArray lhs, in NDArray rhs)
 #else
 	            case NPTypeCode.Boolean: return AddBoolean(lhs, rhs);
 	            case NPTypeCode.Byte: return AddByte(lhs, rhs);
-	            case NPTypeCode.Int16: return AddInt16(lhs, rhs);
-	            case NPTypeCode.UInt16: return AddUInt16(lhs, rhs);
 	            case NPTypeCode.Int32: return AddInt32(lhs, rhs);
-	            case NPTypeCode.UInt32: return AddUInt32(lhs, rhs);
 	            case NPTypeCode.Int64: return AddInt64(lhs, rhs);
-	            case NPTypeCode.UInt64: return AddUInt64(lhs, rhs);
-	            case NPTypeCode.Char: return AddChar(lhs, rhs);
-	            case NPTypeCode.Double: return AddDouble(lhs, rhs);
 	            case NPTypeCode.Single: return AddSingle(lhs, rhs);
-	            case NPTypeCode.Decimal: return AddDecimal(lhs, rhs);
+	            case NPTypeCode.Double: return AddDouble(lhs, rhs);
 	            default:
 		            throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Ceil.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Ceil.cs
index e0d452224..5ce20381a 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Ceil.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Ceil.cs
@@ -21,7 +21,7 @@ public override NDArray Ceil(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,31 +30,19 @@ public override NDArray Ceil(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Ceiling(*(out_addr + i))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Ceiling(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Ceiling(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Ceiling(*(out_addr + i))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Ceiling(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Clip.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Clip.cs
index f875d8a60..9e1417ede 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Clip.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Clip.cs
@@ -23,7 +23,7 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                 {
                     switch (@out.GetTypeCode)
                     {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -61,281 +61,119 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
 	                default:
 		                throw new NotSupportedException();
 #else
-                        case NPTypeCode.Byte:
-                        {
-                            var minval = Converts.ToByte(min);
-                            var maxval = Converts.ToByte(max);
-                            var out_addr = (byte*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            var minval = Converts.ToInt16(min);
-                            var maxval = Converts.ToInt16(max);
-                            var out_addr = (short*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            var minval = Converts.ToUInt16(min);
-                            var maxval = Converts.ToUInt16(max);
-                            var out_addr = (ushort*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            var minval = Converts.ToInt32(min);
-                            var maxval = Converts.ToInt32(max);
-                            var out_addr = (int*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            var minval = Converts.ToUInt32(min);
-                            var maxval = Converts.ToUInt32(max);
-                            var out_addr = (uint*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            var minval = Converts.ToInt64(min);
-                            var maxval = Converts.ToInt64(max);
-                            var out_addr = (long*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            var minval = Converts.ToUInt64(min);
-                            var maxval = Converts.ToUInt64(max);
-                            var out_addr = (ulong*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            var minval = Converts.ToChar(min);
-                            var maxval = Converts.ToChar(max);
-                            var out_addr = (char*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            var minval = Converts.ToDouble(min);
-                            var maxval = Converts.ToDouble(max);
-                            var out_addr = (double*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            var minval = Converts.ToSingle(min);
-                            var maxval = Converts.ToSingle(max);
-                            var out_addr = (float*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            var minval = Converts.ToDecimal(min);
-                            var maxval = Converts.ToDecimal(max);
-                            var out_addr = (decimal*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        default:
-                            throw new NotSupportedException();
-#endif
-                    }
-                }
-            else if (min != null)
-            {
-                unsafe
-                {
-                    switch (@out.GetTypeCode)
-                    {
-#if _REGEN
-                    %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
-	                case NPTypeCode.#1:
+	                case NPTypeCode.Byte:
 	                {
-                        var minval = Converts.To#1(min);
-                        var out_addr = (#2*)@out.Address;
+                        var minval = Converts.ToByte(min);
+                        var maxval = Converts.ToByte(max);
+                        var out_addr = (byte*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
-                            if (val < minval)
+                            if (val > maxval)
+                                val = maxval;
+                            else if (val < minval)
                                 val = minval;
                             *(out_addr + i) = val;
                         });
                         return @out;
 	                }
-	                %
-                    case NPTypeCode.Decimal:
-                    {
-                        var minval = Converts.ToDecimal(min);
-                        var out_addr = (decimal*)@out.Address;
+	                case NPTypeCode.Int32:
+	                {
+                        var minval = Converts.ToInt32(min);
+                        var maxval = Converts.ToInt32(max);
+                        var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
-                            if (val < minval)
+                            if (val > maxval)
+                                val = maxval;
+                            else if (val < minval)
                                 val = minval;
                             *(out_addr + i) = val;
                         });
                         return @out;
 	                }
-	                default:
-		                throw new NotSupportedException();
-#else
-	                case NPTypeCode.Byte:
+	                case NPTypeCode.Int64:
 	                {
-                        var minval = Converts.ToByte(min);
-                        var out_addr = (byte*)@out.Address;
+                        var minval = Converts.ToInt64(min);
+                        var maxval = Converts.ToInt64(max);
+                        var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
-                            if (val < minval)
+                            if (val > maxval)
+                                val = maxval;
+                            else if (val < minval)
                                 val = minval;
                             *(out_addr + i) = val;
                         });
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
+	                case NPTypeCode.Single:
 	                {
-                        var minval = Converts.ToInt16(min);
-                        var out_addr = (short*)@out.Address;
+                        var minval = Converts.ToSingle(min);
+                        var maxval = Converts.ToSingle(max);
+                        var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
-                            if (val < minval)
+                            if (val > maxval)
+                                val = maxval;
+                            else if (val < minval)
                                 val = minval;
                             *(out_addr + i) = val;
                         });
                         return @out;
 	                }
-	                case NPTypeCode.UInt16:
+	                case NPTypeCode.Double:
 	                {
-                        var minval = Converts.ToUInt16(min);
-                        var out_addr = (ushort*)@out.Address;
+                        var minval = Converts.ToDouble(min);
+                        var maxval = Converts.ToDouble(max);
+                        var out_addr = (double*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
-                            if (val < minval)
+                            if (val > maxval)
+                                val = maxval;
+                            else if (val < minval)
                                 val = minval;
                             *(out_addr + i) = val;
                         });
                         return @out;
 	                }
-	                case NPTypeCode.Int32:
-	                {
-                        var minval = Converts.ToInt32(min);
-                        var out_addr = (int*)@out.Address;
+                    case NPTypeCode.Decimal:
+                    {
+                        var minval = Converts.ToDecimal(min);
+                        var maxval = Converts.ToDecimal(max);
+                        var out_addr = (decimal*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
-                            if (val < minval)
+                            if (val > maxval)
+                                val = maxval;
+                            else if (val < minval)
                                 val = minval;
                             *(out_addr + i) = val;
                         });
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
+	                default:
+		                throw new NotSupportedException();
+#endif
+                    }
+                }
+            else if (min != null)
+            {
+                unsafe
+                {
+                    switch (@out.GetTypeCode)
+                    {
+#if _REGEN1
+                    %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
+	                case NPTypeCode.#1:
 	                {
-                        var minval = Converts.ToUInt32(min);
-                        var out_addr = (uint*)@out.Address;
+                        var minval = Converts.To#1(min);
+                        var out_addr = (#2*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
@@ -345,10 +183,11 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                         });
                         return @out;
 	                }
-	                case NPTypeCode.Int64:
-	                {
-                        var minval = Converts.ToInt64(min);
-                        var out_addr = (long*)@out.Address;
+	                %
+                    case NPTypeCode.Decimal:
+                    {
+                        var minval = Converts.ToDecimal(min);
+                        var out_addr = (decimal*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
@@ -358,10 +197,13 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                         });
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
+	                default:
+		                throw new NotSupportedException();
+#else
+	                case NPTypeCode.Byte:
 	                {
-                        var minval = Converts.ToUInt64(min);
-                        var out_addr = (ulong*)@out.Address;
+                        var minval = Converts.ToByte(min);
+                        var out_addr = (byte*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
@@ -371,10 +213,10 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                         });
                         return @out;
 	                }
-	                case NPTypeCode.Char:
+	                case NPTypeCode.Int32:
 	                {
-                        var minval = Converts.ToChar(min);
-                        var out_addr = (char*)@out.Address;
+                        var minval = Converts.ToInt32(min);
+                        var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
@@ -384,10 +226,10 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                         });
                         return @out;
 	                }
-	                case NPTypeCode.Double:
+	                case NPTypeCode.Int64:
 	                {
-                        var minval = Converts.ToDouble(min);
-                        var out_addr = (double*)@out.Address;
+                        var minval = Converts.ToInt64(min);
+                        var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
@@ -410,6 +252,19 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                         });
                         return @out;
 	                }
+	                case NPTypeCode.Double:
+	                {
+                        var minval = Converts.ToDouble(min);
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i =>
+                        {
+                            var val = *(out_addr + i);
+                            if (val < minval)
+                                val = minval;
+                            *(out_addr + i) = val;
+                        });
+                        return @out;
+	                }
                     case NPTypeCode.Decimal:
                     {
                         var minval = Converts.ToDecimal(min);
@@ -435,7 +290,7 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                 {
                     switch (@out.GetTypeCode)
                     {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -480,32 +335,6 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                         });
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var maxval = Converts.ToInt16(max);
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i =>
-                        {
-                            var val = *(out_addr + i);
-                            if (val > maxval)
-                                val = maxval;
-                            *(out_addr + i) = val;
-                        });
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var maxval = Converts.ToUInt16(max);
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i =>
-                        {
-                            var val = *(out_addr + i);
-                            if (val > maxval)
-                                val = maxval;
-                            *(out_addr + i) = val;
-                        });
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var maxval = Converts.ToInt32(max);
@@ -519,19 +348,6 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                         });
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var maxval = Converts.ToUInt32(max);
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i =>
-                        {
-                            var val = *(out_addr + i);
-                            if (val > maxval)
-                                val = maxval;
-                            *(out_addr + i) = val;
-                        });
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var maxval = Converts.ToInt64(max);
@@ -545,23 +361,10 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                         });
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var maxval = Converts.ToUInt64(max);
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i =>
-                        {
-                            var val = *(out_addr + i);
-                            if (val > maxval)
-                                val = maxval;
-                            *(out_addr + i) = val;
-                        });
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
+	                case NPTypeCode.Single:
 	                {
-                        var maxval = Converts.ToChar(max);
-                        var out_addr = (char*)@out.Address;
+                        var maxval = Converts.ToSingle(max);
+                        var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i =>
                         {
                             var val = *(out_addr + i);
@@ -584,19 +387,6 @@ public override NDArray Clip(in NDArray lhs, in ValueType min, in ValueType max,
                         });
                         return @out;
 	                }
-	                case NPTypeCode.Single:
-	                {
-                        var maxval = Converts.ToSingle(max);
-                        var out_addr = (float*)@out.Address;
-                        Parallel.For(0, len, i =>
-                        {
-                            var val = *(out_addr + i);
-                            if (val > maxval)
-                                val = maxval;
-                            *(out_addr + i) = val;
-                        });
-                        return @out;
-	                }
                     case NPTypeCode.Decimal:
                     {
                         var maxval = Converts.ToDecimal(max);
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.ClipNDArray.cs b/src/NumSharp.Core/Backends/Default/Math/Default.ClipNDArray.cs
index 712e9f4c1..9396b45c4 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.ClipNDArray.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.ClipNDArray.cs
@@ -31,7 +31,7 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                 {
                     switch (@out.GetTypeCode)
                     {
-#if _REGEN
+#if _REGEN1
                         %foreach except(supported_numericals),except(supported_numericals_lowercase)%
 	                    case NPTypeCode.#1:
 	                    {
@@ -53,8 +53,8 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
 	                    default:
 		                    throw new NotSupportedException();
 #else
-                        case NPTypeCode.Byte:
-                        {
+	                    case NPTypeCode.Byte:
+	                    {
                             var out_addr = (byte*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -68,41 +68,9 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            var out_addr = (short*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToInt16(_max.GetAtIndex(i));
-                                var minval = Converts.ToInt16(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            var out_addr = (ushort*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToUInt16(_max.GetAtIndex(i));
-                                var minval = Converts.ToUInt16(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Int32:
-                        {
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
                             var out_addr = (int*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -116,25 +84,9 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            var out_addr = (uint*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToUInt32(_max.GetAtIndex(i));
-                                var minval = Converts.ToUInt32(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Int64:
-                        {
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
                             var out_addr = (long*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -148,57 +100,9 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            var out_addr = (ulong*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToUInt64(_max.GetAtIndex(i));
-                                var minval = Converts.ToUInt64(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            var out_addr = (char*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToChar(_max.GetAtIndex(i));
-                                var minval = Converts.ToChar(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            var out_addr = (double*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToDouble(_max.GetAtIndex(i));
-                                var minval = Converts.ToDouble(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                else if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Single:
-                        {
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
                             var out_addr = (float*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -212,14 +116,14 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            var out_addr = (decimal*)@out.Address;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+                            var out_addr = (double*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
-                                var maxval = Converts.ToDecimal(_max.GetAtIndex(i));
-                                var minval = Converts.ToDecimal(_min.GetAtIndex(i));
+                                var maxval = Converts.ToDouble(_max.GetAtIndex(i));
+                                var minval = Converts.ToDouble(_min.GetAtIndex(i));
                                 var val = *(out_addr + i);
                                 if (val > maxval)
                                     val = maxval;
@@ -228,10 +132,9 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
 #endif
                     }
                 }
@@ -241,7 +144,7 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                 {
                     switch (@out.GetTypeCode)
                     {
-#if _REGEN
+#if _REGEN1
                         %foreach except(supported_numericals),except(supported_numericals_lowercase)%
 	                    case NPTypeCode.#1:
 	                    {
@@ -261,8 +164,8 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
 		                    throw new NotSupportedException();
 #else
 
-                        case NPTypeCode.Byte:
-                        {
+	                    case NPTypeCode.Byte:
+	                    {
                             var out_addr = (byte*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -273,35 +176,9 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            var out_addr = (short*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var minval = Converts.ToInt16(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            var out_addr = (ushort*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var minval = Converts.ToUInt16(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Int32:
-                        {
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
                             var out_addr = (int*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -312,22 +189,9 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            var out_addr = (uint*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var minval = Converts.ToUInt32(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Int64:
-                        {
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
                             var out_addr = (long*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -338,48 +202,9 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            var out_addr = (ulong*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var minval = Converts.ToUInt64(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            var out_addr = (char*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var minval = Converts.ToChar(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            var out_addr = (double*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var minval = Converts.ToDouble(_min.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val < minval)
-                                    val = minval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Single:
-                        {
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
                             var out_addr = (float*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -390,22 +215,22 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            var out_addr = (decimal*)@out.Address;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+                            var out_addr = (double*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
-                                var minval = Converts.ToDecimal(_min.GetAtIndex(i));
+                                var minval = Converts.ToDouble(_min.GetAtIndex(i));
                                 var val = *(out_addr + i);
                                 if (val < minval)
                                     val = minval;
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        default:
-                            throw new NotSupportedException();
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
 #endif
                     }
                 }
@@ -416,7 +241,7 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                 {
                     switch (@out.GetTypeCode)
                     {
-#if _REGEN
+#if _REGEN1
                         %foreach except(supported_numericals),except(supported_numericals_lowercase)%
 	                    case NPTypeCode.#1:
 	                    {
@@ -436,8 +261,8 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
 		                    throw new NotSupportedException();
 #else
 
-                        case NPTypeCode.Byte:
-                        {
+	                    case NPTypeCode.Byte:
+	                    {
                             var out_addr = (byte*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -448,35 +273,9 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            var out_addr = (short*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToInt16(_max.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            var out_addr = (ushort*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToUInt16(_max.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Int32:
-                        {
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
                             var out_addr = (int*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -487,22 +286,9 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            var out_addr = (uint*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToUInt32(_max.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Int64:
-                        {
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
                             var out_addr = (long*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -513,48 +299,9 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            var out_addr = (ulong*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToUInt64(_max.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            var out_addr = (char*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToChar(_max.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            var out_addr = (double*)@out.Address;
-                            Parallel.For(0, len, i =>
-                            {
-                                var maxval = Converts.ToDouble(_max.GetAtIndex(i));
-                                var val = *(out_addr + i);
-                                if (val > maxval)
-                                    val = maxval;
-                                *(out_addr + i) = val;
-                            });
-                            return @out;
-                        }
-                        case NPTypeCode.Single:
-                        {
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
                             var out_addr = (float*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
@@ -565,22 +312,22 @@ public override NDArray ClipNDArray(in NDArray lhs, in NDArray min, in NDArray m
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            var out_addr = (decimal*)@out.Address;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+                            var out_addr = (double*)@out.Address;
                             Parallel.For(0, len, i =>
                             {
-                                var maxval = Converts.ToDecimal(_max.GetAtIndex(i));
+                                var maxval = Converts.ToDouble(_max.GetAtIndex(i));
                                 var val = *(out_addr + i);
                                 if (val > maxval)
                                     val = maxval;
                                 *(out_addr + i) = val;
                             });
                             return @out;
-                        }
-                        default:
-                            throw new NotSupportedException();
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
 #endif
                     }
                 }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Cos.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Cos.cs
index faf3dda55..d7c418490 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Cos.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Cos.cs
@@ -21,7 +21,7 @@ public override NDArray Cos(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,12 +30,6 @@ public override NDArray Cos(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Cos(Converts.ToDouble(*(out_addr + i)))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -45,64 +39,28 @@ public override NDArray Cos(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Cos(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Cos(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Cos(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Cos(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Cos(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Cos(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Cos(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Cos(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Cos(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Cos(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Cos(Converts.ToDouble(*(out_addr + i)))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Cos(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Cosh.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Cosh.cs
index 7d96141fb..7185ef807 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Cosh.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Cosh.cs
@@ -20,7 +20,7 @@ public override NDArray Cosh(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -29,12 +29,6 @@ public override NDArray Cosh(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Cosh(Converts.ToDouble(*(out_addr + i)))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -44,64 +38,28 @@ public override NDArray Cosh(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Cosh(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Cosh(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Cosh(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Cosh(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Cosh(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Cosh(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Cosh(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Cosh(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Cosh(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Cosh(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Cosh(Converts.ToDouble(*(out_addr + i)))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Cosh(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Divide.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Divide.cs
index 9412c10aa..bacac68f0 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Divide.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Divide.cs
@@ -8,27 +8,21 @@ public override NDArray Divide(in NDArray lhs, in NDArray rhs)
         {
             switch (lhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return Divide#1(lhs, rhs);
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return DivideBoolean(lhs, rhs);
-                case NPTypeCode.Byte: return DivideByte(lhs, rhs);
-                case NPTypeCode.Int16: return DivideInt16(lhs, rhs);
-                case NPTypeCode.UInt16: return DivideUInt16(lhs, rhs);
-                case NPTypeCode.Int32: return DivideInt32(lhs, rhs);
-                case NPTypeCode.UInt32: return DivideUInt32(lhs, rhs);
-                case NPTypeCode.Int64: return DivideInt64(lhs, rhs);
-                case NPTypeCode.UInt64: return DivideUInt64(lhs, rhs);
-                case NPTypeCode.Char: return DivideChar(lhs, rhs);
-                case NPTypeCode.Double: return DivideDouble(lhs, rhs);
-                case NPTypeCode.Single: return DivideSingle(lhs, rhs);
-                case NPTypeCode.Decimal: return DivideDecimal(lhs, rhs);
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return DivideBoolean(lhs, rhs);
+	            case NPTypeCode.Byte: return DivideByte(lhs, rhs);
+	            case NPTypeCode.Int32: return DivideInt32(lhs, rhs);
+	            case NPTypeCode.Int64: return DivideInt64(lhs, rhs);
+	            case NPTypeCode.Single: return DivideSingle(lhs, rhs);
+	            case NPTypeCode.Double: return DivideDouble(lhs, rhs);
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Exp.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Exp.cs
index 6f4da2057..03f08bbcb 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Exp.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Exp.cs
@@ -21,7 +21,7 @@ public override NDArray Exp(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,12 +30,6 @@ public override NDArray Exp(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)Converts.ToDouble(DecimalEx.Exp(*(out_addr + i))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -45,64 +39,28 @@ public override NDArray Exp(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Exp(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Exp(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Exp(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Exp(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Exp(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Exp(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Exp(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Exp(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Exp(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Exp(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)Converts.ToDouble(DecimalEx.Exp(*(out_addr + i))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Exp(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Exp2.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Exp2.cs
index 79be3e384..ee2b67577 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Exp2.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Exp2.cs
@@ -23,7 +23,7 @@ public override NDArray Exp2(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
 
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
@@ -33,12 +33,6 @@ public override NDArray Exp2(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-                    {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = DecimalEx.Pow(2, *(out_addr + i)));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -48,46 +42,22 @@ public override NDArray Exp2(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Pow(2, *(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Pow(2, *(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Pow(2, *(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Pow(2, *(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Pow(2, *(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Pow(2, *(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Pow(2, *(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
+	                case NPTypeCode.Single:
 	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Pow(2, *(out_addr + i))));
+                        var out_addr = (float*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Pow(2, *(out_addr + i))));
                         return @out;
 	                }
 	                case NPTypeCode.Double:
@@ -96,18 +66,6 @@ public override NDArray Exp2(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Pow(2, *(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Single:
-	                {
-                        var out_addr = (float*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Pow(2, *(out_addr + i))));
-                        return @out;
-	                }
-                    case NPTypeCode.Decimal:
-                    {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = DecimalEx.Pow(2, *(out_addr + i)));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Expm1.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Expm1.cs
index 10a784f8d..7f639cf42 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Expm1.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Expm1.cs
@@ -21,7 +21,7 @@ public override NDArray Expm1(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,12 +30,6 @@ public override NDArray Expm1(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)Converts.ToDouble(DecimalEx.Exp(*(out_addr + i)) - 1m));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -45,64 +39,28 @@ public override NDArray Expm1(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Exp(*(out_addr + i)) - 1));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Exp(*(out_addr + i)) - 1));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Exp(*(out_addr + i)) - 1));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Exp(*(out_addr + i)) - 1));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Exp(*(out_addr + i)) - 1));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Exp(*(out_addr + i)) - 1));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Exp(*(out_addr + i)) - 1));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Exp(*(out_addr + i)) - 1));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Exp(*(out_addr + i)) - 1));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Exp(*(out_addr + i)) - 1));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)Converts.ToDouble(DecimalEx.Exp(*(out_addr + i)) - 1m));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Exp(*(out_addr + i)) - 1));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Floor.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Floor.cs
index c51a1f309..111f2b5a4 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Floor.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Floor.cs
@@ -21,45 +21,20 @@ public override NDArray Floor(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
-                    %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
-	                case NPTypeCode.#1:
-	                {
-                        var out_addr = (#2*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.To#1(Math.Floor(*(out_addr + i))));
-                        return @out;
-	                }
-	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Floor(*(out_addr + i))));
-                        return @out;
-	                }
-	                default:
-		                throw new NotSupportedException();
-#else
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Floor(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Floor(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Floor(*(out_addr + i))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Floor(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
 		                throw new NotSupportedException();
-#endif
                 }
             }
         }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Log.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Log.cs
index eb67fbcc8..77b0876fb 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Log.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Log.cs
@@ -21,7 +21,7 @@ public override NDArray Log(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,12 +30,6 @@ public override NDArray Log(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Log(*(out_addr + i))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -45,64 +39,28 @@ public override NDArray Log(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Log(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Log(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Log(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Log(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Log(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Log(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Log(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Log(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Log(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Log(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Log(*(out_addr + i))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Log(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Log10.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Log10.cs
index 993584c67..7b27e004a 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Log10.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Log10.cs
@@ -21,7 +21,7 @@ public override NDArray Log10(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,12 +30,6 @@ public override NDArray Log10(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Log10(*(out_addr + i))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -45,64 +39,28 @@ public override NDArray Log10(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Log10(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Log10(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Log10(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Log10(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Log10(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Log10(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Log10(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Log10(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Log10(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Log10(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Log10(*(out_addr + i))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Log10(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Log1p.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Log1p.cs
index d5e0f98e4..a76e8fcc4 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Log1p.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Log1p.cs
@@ -21,7 +21,7 @@ public override NDArray Log1p(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal"), except(supported_numericals_onevales, "1m")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,12 +30,6 @@ public override NDArray Log1p(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Log10(*(out_addr + i) + 1m)));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -45,64 +39,28 @@ public override NDArray Log1p(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Log10(*(out_addr + i) + 1)));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Log10(*(out_addr + i) + 1)));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Log10(*(out_addr + i) + 1)));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Log10(*(out_addr + i) + 1)));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Log10(*(out_addr + i) + 1u)));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Log10(*(out_addr + i) + 1L)));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Log10(*(out_addr + i) + 1UL)));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Log10(*(out_addr + i) + 1)));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Log10(*(out_addr + i) + 1d)));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Log10(*(out_addr + i) + 1f)));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Log10(*(out_addr + i) + 1m)));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Log10(*(out_addr + i) + 1d)));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Log2.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Log2.cs
index bd22bb7e6..7d159adb8 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Log2.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Log2.cs
@@ -21,7 +21,7 @@ public override NDArray Log2(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,12 +30,6 @@ public override NDArray Log2(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Log(*(out_addr + i), 2)));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -45,64 +39,28 @@ public override NDArray Log2(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Log(*(out_addr + i), 2)));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Log(*(out_addr + i), 2)));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Log(*(out_addr + i), 2)));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Log(*(out_addr + i), 2)));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Log(*(out_addr + i), 2)));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Log(*(out_addr + i), 2)));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Log(*(out_addr + i), 2)));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Log(*(out_addr + i), 2)));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Log(*(out_addr + i), 2)));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Log(*(out_addr + i), 2)));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Log(*(out_addr + i), 2)));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Log(*(out_addr + i), 2)));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Mod.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Mod.cs
index 492841ba3..37522e13a 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Mod.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Mod.cs
@@ -8,7 +8,7 @@ public override NDArray Mod(in NDArray lhs, in NDArray rhs)
         {
             switch (lhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return Mod#1(lhs, rhs);
 	            %
@@ -17,16 +17,10 @@ public override NDArray Mod(in NDArray lhs, in NDArray rhs)
 #else
 	            case NPTypeCode.Boolean: return ModBoolean(lhs, rhs);
 	            case NPTypeCode.Byte: return ModByte(lhs, rhs);
-	            case NPTypeCode.Int16: return ModInt16(lhs, rhs);
-	            case NPTypeCode.UInt16: return ModUInt16(lhs, rhs);
 	            case NPTypeCode.Int32: return ModInt32(lhs, rhs);
-	            case NPTypeCode.UInt32: return ModUInt32(lhs, rhs);
 	            case NPTypeCode.Int64: return ModInt64(lhs, rhs);
-	            case NPTypeCode.UInt64: return ModUInt64(lhs, rhs);
-	            case NPTypeCode.Char: return ModChar(lhs, rhs);
-	            case NPTypeCode.Double: return ModDouble(lhs, rhs);
 	            case NPTypeCode.Single: return ModSingle(lhs, rhs);
-	            case NPTypeCode.Decimal: return ModDecimal(lhs, rhs);
+	            case NPTypeCode.Double: return ModDouble(lhs, rhs);
 	            default:
 		            throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Modf.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Modf.cs
index f1b798d6b..2645166a2 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Modf.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Modf.cs
@@ -28,54 +28,35 @@ public override (NDArray Fractional, NDArray Intergral) ModF(in NDArray nd, NPTy
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Frac(*(out_addr + i))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
                     case NPTypeCode.Double:
-                    {
-                        var out_addr = (double*)@out.Address;
-                        var out1_addr = (double*)@out1.Address;
-                        Parallel.For(0, len, (i) =>
                         {
-                            var trunc = Math.Truncate(*(out_addr + i));
-                            *(out_addr + i) = Converts.ToDouble(*(out_addr + i) - trunc);
-                            *(out1_addr + i) = trunc;
-                        });
+                            var out_addr = (double*)@out.Address;
+                            var out1_addr = (double*)@out1.Address;
+                            Parallel.For(0, len, (i) =>
+                            {
+                                var trunc = Math.Truncate(*(out_addr + i));
+                                *(out_addr + i) = Converts.ToDouble(*(out_addr + i) - trunc);
+                                *(out1_addr + i) = trunc;
+                            });
 
-                        return (@out, @out1);
-                    }
+                            return (@out, @out1);
+                        }
                     case NPTypeCode.Single:
-                    {
-                        var out_addr = (float*)@out.Address;
-                        var out1_addr = (float*)@out1.Address;
-                        Parallel.For(0, len, (i) =>
-                        {
-                            var trunc = Math.Truncate(*(out_addr + i));
-                            *(out_addr + i) = Converts.ToSingle(*(out_addr + i) - trunc);
-                            *(out1_addr + i) = Convert.ToSingle(trunc);
-                        });
-
-                        return (@out, @out1);
-                    }
-                    case NPTypeCode.Decimal:
-                    {
-                        var out_addr = (decimal*)@out.Address;
-                        var out1_addr = (decimal*)@out1.Address;
-                        Parallel.For(0, len, (i) =>
                         {
-                            var trunc = Math.Truncate(*(out_addr + i));
-                            *(out_addr + i) = *(out_addr + i) - trunc;
-                            *(out1_addr + i) = trunc;
-                        });
+                            var out_addr = (float*)@out.Address;
+                            var out1_addr = (float*)@out1.Address;
+                            Parallel.For(0, len, (i) =>
+                            {
+                                var trunc = Math.Truncate(*(out_addr + i));
+                                *(out_addr + i) = Converts.ToSingle(*(out_addr + i) - trunc);
+                                *(out1_addr + i) = Convert.ToSingle(trunc);
+                            });
 
-                        return (@out, @out1);
-                    }
+                            return (@out, @out1);
+                        }
                     default:
                         throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Multiply.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Multiply.cs
index 945411795..e1c7f4ded 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Multiply.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Multiply.cs
@@ -8,7 +8,7 @@ public override NDArray Multiply(NDArray lhs, NDArray rhs)
         {
             switch (lhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return Multiply#1(lhs, rhs);
 	            %
@@ -17,16 +17,10 @@ public override NDArray Multiply(NDArray lhs, NDArray rhs)
 #else
 	            case NPTypeCode.Boolean: return MultiplyBoolean(lhs, rhs);
 	            case NPTypeCode.Byte: return MultiplyByte(lhs, rhs);
-	            case NPTypeCode.Int16: return MultiplyInt16(lhs, rhs);
-	            case NPTypeCode.UInt16: return MultiplyUInt16(lhs, rhs);
 	            case NPTypeCode.Int32: return MultiplyInt32(lhs, rhs);
-	            case NPTypeCode.UInt32: return MultiplyUInt32(lhs, rhs);
 	            case NPTypeCode.Int64: return MultiplyInt64(lhs, rhs);
-	            case NPTypeCode.UInt64: return MultiplyUInt64(lhs, rhs);
-	            case NPTypeCode.Char: return MultiplyChar(lhs, rhs);
-	            case NPTypeCode.Double: return MultiplyDouble(lhs, rhs);
 	            case NPTypeCode.Single: return MultiplySingle(lhs, rhs);
-	            case NPTypeCode.Decimal: return MultiplyDecimal(lhs, rhs);
+	            case NPTypeCode.Double: return MultiplyDouble(lhs, rhs);
 	            default:
 		            throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Negate.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Negate.cs
index af0d231a4..a0e35adf0 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Negate.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Negate.cs
@@ -24,7 +24,7 @@ public override NDArray Negate(in NDArray nd)
                             *(out_addr + i) = !*(addr + i);
                         return @out;
                     }
-#if _REGEN
+#if _REGEN1
 	                %foreach supported_numericals_unsigned,supported_numericals_unsigned_lowercase,supported_numericals_unsigned_defaultvals%
 	                case NPTypeCode.#1:
 	                {
@@ -41,27 +41,14 @@ public override NDArray Negate(in NDArray nd)
                                 *(out_addr + i) = Converts.To#1(~val+1);
                         }
 
-                        return @out;
-	                }
-	                %
-                    %foreach supported_numericals_signed,supported_numericals_signed_lowercase%
-	                case NPTypeCode.#1:
-	                {
-                        var out_addr = (#2*)@out.Address;
-                        var addr = (#2*)nd.Address;
-                        var len = nd.size;
-
-                        for (int i = 0; i < len; i++)
-                            *(out_addr + i) = Converts.To#1(-*(addr + i));
-
                         return @out;
 	                }
 	                %
 	                default:
 		                throw new NotSupportedException();
 #else
-                    case NPTypeCode.Byte:
-                    {
+	                case NPTypeCode.Byte:
+	                {
                         var out_addr = (byte*)@out.Address;
                         var addr = (byte*)nd.Address;
                         var len = nd.size;
@@ -72,14 +59,13 @@ public override NDArray Negate(in NDArray nd)
                             if (val == 0)
                                 *(out_addr + i) = 0;
                             else
-                                *(out_addr + i) = Converts.ToByte(~val + 1);
+                                *(out_addr + i) = Converts.ToByte(~val+1);
                         }
 
                         return @out;
-                    }
-
-                    case NPTypeCode.UInt16:
-                    {
+	                }
+	                case NPTypeCode.UInt16:
+	                {
                         var out_addr = (ushort*)@out.Address;
                         var addr = (ushort*)nd.Address;
                         var len = nd.size;
@@ -90,14 +76,13 @@ public override NDArray Negate(in NDArray nd)
                             if (val == 0)
                                 *(out_addr + i) = 0;
                             else
-                                *(out_addr + i) = Converts.ToUInt16(~val + 1);
+                                *(out_addr + i) = Converts.ToUInt16(~val+1);
                         }
 
                         return @out;
-                    }
-
-                    case NPTypeCode.UInt32:
-                    {
+	                }
+	                case NPTypeCode.UInt32:
+	                {
                         var out_addr = (uint*)@out.Address;
                         var addr = (uint*)nd.Address;
                         var len = nd.size;
@@ -108,14 +93,13 @@ public override NDArray Negate(in NDArray nd)
                             if (val == 0U)
                                 *(out_addr + i) = 0U;
                             else
-                                *(out_addr + i) = Converts.ToUInt32(~val + 1);
+                                *(out_addr + i) = Converts.ToUInt32(~val+1);
                         }
 
                         return @out;
-                    }
-
-                    case NPTypeCode.UInt64:
-                    {
+	                }
+	                case NPTypeCode.UInt64:
+	                {
                         var out_addr = (ulong*)@out.Address;
                         var addr = (ulong*)nd.Address;
                         var len = nd.size;
@@ -126,104 +110,13 @@ public override NDArray Negate(in NDArray nd)
                             if (val == 0UL)
                                 *(out_addr + i) = 0UL;
                             else
-                                *(out_addr + i) = Converts.ToUInt64(~val + 1);
+                                *(out_addr + i) = Converts.ToUInt64(~val+1);
                         }
 
                         return @out;
-                    }
-
-                    case NPTypeCode.Char:
-                    {
-                        var out_addr = (char*)@out.Address;
-                        var addr = (char*)nd.Address;
-                        var len = nd.size;
-
-                        for (int i = 0; i < len; i++)
-                        {
-                            var val = *(addr + i);
-                            if (val == '\0')
-                                *(out_addr + i) = '\0';
-                            else
-                                *(out_addr + i) = Converts.ToChar(~val + 1);
-                        }
-
-                        return @out;
-                    }
-
-                    case NPTypeCode.Int16:
-                    {
-                        var out_addr = (short*)@out.Address;
-                        var addr = (short*)nd.Address;
-                        var len = nd.size;
-
-                        for (int i = 0; i < len; i++)
-                            *(out_addr + i) = Converts.ToInt16(-*(addr + i));
-
-                        return @out;
-                    }
-
-                    case NPTypeCode.Int32:
-                    {
-                        var out_addr = (int*)@out.Address;
-                        var addr = (int*)nd.Address;
-                        var len = nd.size;
-
-                        for (int i = 0; i < len; i++)
-                            *(out_addr + i) = Converts.ToInt32(-*(addr + i));
-
-                        return @out;
-                    }
-
-                    case NPTypeCode.Int64:
-                    {
-                        var out_addr = (long*)@out.Address;
-                        var addr = (long*)nd.Address;
-                        var len = nd.size;
-
-                        for (int i = 0; i < len; i++)
-                            *(out_addr + i) = Converts.ToInt64(-*(addr + i));
-
-                        return @out;
-                    }
-
-                    case NPTypeCode.Double:
-                    {
-                        var out_addr = (double*)@out.Address;
-                        var addr = (double*)nd.Address;
-                        var len = nd.size;
-
-                        for (int i = 0; i < len; i++)
-                            *(out_addr + i) = Converts.ToDouble(-*(addr + i));
-
-                        return @out;
-                    }
-
-                    case NPTypeCode.Single:
-                    {
-                        var out_addr = (float*)@out.Address;
-                        var addr = (float*)nd.Address;
-                        var len = nd.size;
-
-                        for (int i = 0; i < len; i++)
-                            *(out_addr + i) = Converts.ToSingle(-*(addr + i));
-
-                        return @out;
-                    }
-
-                    case NPTypeCode.Decimal:
-                    {
-                        var out_addr = (decimal*)@out.Address;
-                        var addr = (decimal*)nd.Address;
-                        var len = nd.size;
-
-                        for (int i = 0; i < len; i++)
-                            *(out_addr + i) = Converts.ToDecimal(-*(addr + i));
-
-                        return @out;
-                    }
-
-                    default:
-                        throw new NotSupportedException();
+	                }
+	                default:
+		                throw new NotSupportedException();
 #endif
                 }
             }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Power.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Power.cs
index be8380384..0d67a518d 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Power.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Power.cs
@@ -23,7 +23,7 @@ public override NDArray Power(in NDArray lhs, in ValueType rhs, NPTypeCode? type
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
 
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
@@ -34,13 +34,6 @@ public override NDArray Power(in NDArray lhs, in ValueType rhs, NPTypeCode? type
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-                    {
-                        var right = (decimal) Converts.ToDecimal(rhs);
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = DecimalEx.Pow(*(out_addr + i), right));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -51,20 +44,6 @@ public override NDArray Power(in NDArray lhs, in ValueType rhs, NPTypeCode? type
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Pow(*(out_addr + i), right)));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var right = Converts.ToDouble(rhs);
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Pow(*(out_addr + i), right)));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var right = Converts.ToDouble(rhs);
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Pow(*(out_addr + i), right)));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var right = Converts.ToDouble(rhs);
@@ -72,13 +51,6 @@ public override NDArray Power(in NDArray lhs, in ValueType rhs, NPTypeCode? type
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Pow(*(out_addr + i), right)));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var right = Converts.ToDouble(rhs);
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Pow(*(out_addr + i), right)));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var right = Converts.ToDouble(rhs);
@@ -86,18 +58,11 @@ public override NDArray Power(in NDArray lhs, in ValueType rhs, NPTypeCode? type
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Pow(*(out_addr + i), right)));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var right = Converts.ToDouble(rhs);
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Pow(*(out_addr + i), right)));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
+	                case NPTypeCode.Single:
 	                {
                         var right = Converts.ToDouble(rhs);
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Pow(*(out_addr + i), right)));
+                        var out_addr = (float*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Pow(*(out_addr + i), right)));
                         return @out;
 	                }
 	                case NPTypeCode.Double:
@@ -107,20 +72,6 @@ public override NDArray Power(in NDArray lhs, in ValueType rhs, NPTypeCode? type
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Pow(*(out_addr + i), right)));
                         return @out;
 	                }
-	                case NPTypeCode.Single:
-	                {
-                        var right = Converts.ToDouble(rhs);
-                        var out_addr = (float*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Pow(*(out_addr + i), right)));
-                        return @out;
-	                }
-                    case NPTypeCode.Decimal:
-                    {
-                        var right = Converts.ToDecimal(rhs);
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = DecimalEx.Pow(*(out_addr + i), right));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Round.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Round.cs
index 898605f86..e47b5581e 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Round.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Round.cs
@@ -21,45 +21,20 @@ public override NDArray Round(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
-                    %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
-	                case NPTypeCode.#1:
-	                {
-                        var out_addr = (#2*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.To#1(Math.Round(*(out_addr + i))));
-                        return @out;
-	                }
-	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Round(*(out_addr + i))));
-                        return @out;
-	                }
-	                default:
-		                throw new NotSupportedException();
-#else
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Round(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Round(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal.Round(*(out_addr + i))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Round(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
 		                throw new NotSupportedException();
-#endif
                 }
             }
         }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Sign.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Sign.cs
index dfbcadb06..9a66c6679 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Sign.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Sign.cs
@@ -20,7 +20,7 @@ public override NDArray Sign(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -29,12 +29,6 @@ public override NDArray Sign(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Sign(Converts.ToDouble(*(out_addr + i)))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -44,64 +38,28 @@ public override NDArray Sign(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Sign(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Sign(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Sign(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Sign(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Sign(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Sign(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Sign((long)*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Sign(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Sign(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Sign(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Sign(Converts.ToDouble(*(out_addr + i)))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Sign(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Sin.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Sin.cs
index 1b44ce556..87a9dcf8c 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Sin.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Sin.cs
@@ -22,7 +22,7 @@ public override NDArray Sin(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -31,12 +31,6 @@ public override NDArray Sin(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Sin(Converts.ToDouble(*(out_addr + i)))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -46,64 +40,28 @@ public override NDArray Sin(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Sin(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Sin(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Sin(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Sin(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Sin(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Sin(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Sin(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Sin(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Sin(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Sin(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Sin(Converts.ToDouble(*(out_addr + i)))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Sin(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Sinh.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Sinh.cs
index 8627c0120..04bb1c8f7 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Sinh.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Sinh.cs
@@ -21,7 +21,7 @@ public override NDArray Sinh(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,12 +30,6 @@ public override NDArray Sinh(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Sinh(Converts.ToDouble(*(out_addr + i)))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -45,64 +39,28 @@ public override NDArray Sinh(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Sinh(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Sinh(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Sinh(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Sinh(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Sinh(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Sinh(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Sinh(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Sinh(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Sinh(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Sinh(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Sinh(Converts.ToDouble(*(out_addr + i)))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Sinh(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Sqrt.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Sqrt.cs
index dec07d570..b7e98277f 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Sqrt.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Sqrt.cs
@@ -21,7 +21,7 @@ public override NDArray Sqrt(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,12 +30,6 @@ public override NDArray Sqrt(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Sqrt(*(out_addr + i))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -45,64 +39,28 @@ public override NDArray Sqrt(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Sqrt(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Sqrt(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Sqrt(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Sqrt(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Sqrt(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Sqrt(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Sqrt(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Sqrt(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Sqrt(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Sqrt(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Sqrt(*(out_addr + i))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Sqrt(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Subtract.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Subtract.cs
index 85317c55d..05b278686 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Subtract.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Subtract.cs
@@ -8,7 +8,7 @@ public override NDArray Subtract(in NDArray lhs, in NDArray rhs)
         {
             switch (lhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return Subtract#1(lhs, rhs);
 	            %
@@ -17,16 +17,10 @@ public override NDArray Subtract(in NDArray lhs, in NDArray rhs)
 #else
 	            case NPTypeCode.Boolean: return SubtractBoolean(lhs, rhs);
 	            case NPTypeCode.Byte: return SubtractByte(lhs, rhs);
-	            case NPTypeCode.Int16: return SubtractInt16(lhs, rhs);
-	            case NPTypeCode.UInt16: return SubtractUInt16(lhs, rhs);
 	            case NPTypeCode.Int32: return SubtractInt32(lhs, rhs);
-	            case NPTypeCode.UInt32: return SubtractUInt32(lhs, rhs);
 	            case NPTypeCode.Int64: return SubtractInt64(lhs, rhs);
-	            case NPTypeCode.UInt64: return SubtractUInt64(lhs, rhs);
-	            case NPTypeCode.Char: return SubtractChar(lhs, rhs);
-	            case NPTypeCode.Double: return SubtractDouble(lhs, rhs);
 	            case NPTypeCode.Single: return SubtractSingle(lhs, rhs);
-	            case NPTypeCode.Decimal: return SubtractDecimal(lhs, rhs);
+	            case NPTypeCode.Double: return SubtractDouble(lhs, rhs);
 	            default:
 		            throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Tan.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Tan.cs
index e12c4aa9e..326bf29ad 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Tan.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Tan.cs
@@ -21,7 +21,7 @@ public override NDArray Tan(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -30,12 +30,6 @@ public override NDArray Tan(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Tan(*(out_addr + i))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -45,64 +39,28 @@ public override NDArray Tan(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Tan(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Tan(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Tan(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Tan(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Tan(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Tan(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Tan(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Tan(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Tan(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Tan(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (DecimalEx.Tan(*(out_addr + i))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Tan(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Default.Tanh.cs b/src/NumSharp.Core/Backends/Default/Math/Default.Tanh.cs
index 75c318a8b..a73d2da3b 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Default.Tanh.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Default.Tanh.cs
@@ -20,7 +20,7 @@ public override NDArray Tanh(in NDArray nd, NPTypeCode? typeCode = null)
             {
                 switch (@out.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
                     %foreach except(supported_numericals, "Decimal"),except(supported_numericals_lowercase, "decimal")%
 	                case NPTypeCode.#1:
 	                {
@@ -29,12 +29,6 @@ public override NDArray Tanh(in NDArray nd, NPTypeCode? typeCode = null)
                         return @out;
 	                }
 	                %
-                    case NPTypeCode.Decimal:
-	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Tanh(Converts.ToDouble(*(out_addr + i)))));
-                        return @out;
-	                }
 	                default:
 		                throw new NotSupportedException();
 #else
@@ -44,64 +38,28 @@ public override NDArray Tanh(in NDArray nd, NPTypeCode? typeCode = null)
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToByte(Math.Tanh(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt16(Math.Tanh(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.UInt16:
-	                {
-                        var out_addr = (ushort*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt16(Math.Tanh(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt32(Math.Tanh(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt32:
-	                {
-                        var out_addr = (uint*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt32(Math.Tanh(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Int64:
 	                {
                         var out_addr = (long*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToInt64(Math.Tanh(*(out_addr + i))));
                         return @out;
 	                }
-	                case NPTypeCode.UInt64:
-	                {
-                        var out_addr = (ulong*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToUInt64(Math.Tanh(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Char:
-	                {
-                        var out_addr = (char*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToChar(Math.Tanh(*(out_addr + i))));
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Tanh(*(out_addr + i))));
-                        return @out;
-	                }
 	                case NPTypeCode.Single:
 	                {
                         var out_addr = (float*)@out.Address;
                         Parallel.For(0, len, i => *(out_addr + i) = Converts.ToSingle(Math.Tanh(*(out_addr + i))));
                         return @out;
 	                }
-                    case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
-                        Parallel.For(0, len, i => *(out_addr + i) = (decimal)(Math.Tanh(Converts.ToDouble(*(out_addr + i)))));
+                        var out_addr = (double*)@out.Address;
+                        Parallel.For(0, len, i => *(out_addr + i) = Converts.ToDouble(Math.Tanh(*(out_addr + i))));
                         return @out;
 	                }
 	                default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Boolean.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Boolean.cs
index 39b11992d..3f5f83ae2 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Boolean.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Boolean.cs
@@ -28,7 +28,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of bool
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Divide"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,6126 +238,24 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt16(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt16(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt16(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt16(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt16(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt32(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt32(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt32(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt64(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt64(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt64(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToChar(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToChar(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToChar(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToChar(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDouble(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToDouble(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToSingle(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToSingle(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDecimal(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt32(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6365,13 +263,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6379,7 +277,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6389,30 +287,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToInt32(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt64(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6420,13 +318,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6434,7 +332,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6444,30 +342,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToInt64(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToSingle(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6475,13 +373,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6489,7 +387,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6499,30 +397,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToSingle(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDouble(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6530,13 +428,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6544,7 +442,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6554,30 +452,48 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToDouble(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6585,13 +501,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6599,7 +515,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6609,30 +525,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6640,13 +556,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6654,7 +570,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6664,30 +580,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6695,13 +611,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6709,7 +625,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6719,30 +635,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6750,13 +666,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6764,7 +680,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6774,7 +690,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -6835,24 +751,24 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6860,13 +776,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6874,7 +790,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6884,7 +800,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -6894,15 +810,15 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Single: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((float*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7018,24 +934,24 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7043,13 +959,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7057,7 +973,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7067,30 +983,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7098,13 +1014,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7112,7 +1028,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7122,30 +1038,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((bool*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray DivideBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Byte.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Byte.cs
index 0916bc831..87de39410 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Byte.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Byte.cs
@@ -28,7 +28,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of byte
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Divide"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((byte*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray DivideByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Char.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Char.cs
deleted file mode 100644
index 3293f89f9..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Char.cs
+++ /dev/null
@@ -1,8259 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray DivideChar(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of char
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Divide"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((char*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("char"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((char*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Decimal.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Decimal.cs
deleted file mode 100644
index df2385127..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Decimal.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray DivideDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray DivideDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of decimal
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Divide"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((decimal*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("decimal"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((decimal*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Double.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Double.cs
index 7ff376599..df1e2885b 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Double.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Double.cs
@@ -28,7 +28,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of double
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Divide"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((double*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray DivideDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int16.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int16.cs
deleted file mode 100644
index c5d68fe06..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int16.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray DivideInt16(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray DivideInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of short
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Divide"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((short*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("short"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((short*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int32.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int32.cs
index edc0c6be1..12953b1ca 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int32.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int32.cs
@@ -28,7 +28,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of int
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Divide"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((int*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray DivideInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int64.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int64.cs
index 664c99349..7d0e8b090 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int64.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Int64.cs
@@ -34,7 +34,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of long
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Divide"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -244,24 +244,24 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -269,13 +269,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -283,7 +283,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -293,30 +293,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -324,13 +324,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -338,7 +338,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -348,30 +348,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -379,13 +379,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -393,7 +393,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -403,30 +403,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -434,13 +434,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -448,7 +448,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -458,30 +458,48 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -489,13 +507,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -503,7 +521,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -513,30 +531,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -544,13 +562,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -558,7 +576,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -568,30 +586,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -599,13 +617,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -613,7 +631,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -623,30 +641,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -654,13 +672,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -668,7 +686,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -678,7 +696,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -739,24 +757,24 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -764,13 +782,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -778,7 +796,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -788,7 +806,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -798,15 +816,15 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -920,116 +938,6 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1087,24 +995,24 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1112,13 +1020,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1126,7 +1034,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1136,6022 +1044,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7159,13 +1075,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7173,7 +1089,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7183,30 +1099,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7214,13 +1130,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7228,7 +1144,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7238,30 +1154,48 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7269,13 +1203,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7283,7 +1217,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7293,30 +1227,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7324,13 +1258,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7338,7 +1272,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7348,30 +1282,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7379,13 +1313,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7393,7 +1327,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7403,30 +1337,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7434,13 +1368,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7448,7 +1382,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7458,7 +1392,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7519,24 +1453,24 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7544,13 +1478,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7558,7 +1492,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7568,7 +1502,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7578,15 +1512,15 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7702,24 +1636,24 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7727,13 +1661,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7741,7 +1675,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7751,30 +1685,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7782,13 +1716,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7796,7 +1730,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7806,30 +1740,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7837,13 +1771,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7851,7 +1785,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7861,30 +1795,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7892,13 +1826,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7906,7 +1840,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7916,30 +1850,48 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((long*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7947,13 +1899,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7961,7 +1913,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7971,30 +1923,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8002,13 +1954,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8016,7 +1968,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8026,30 +1978,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8057,13 +2009,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8071,7 +2023,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8081,30 +2033,30 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8112,13 +2064,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8126,7 +2078,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8136,7 +2088,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8197,24 +2149,24 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8222,13 +2174,13 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8236,7 +2188,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8246,7 +2198,7 @@ public unsafe NDArray DivideInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Single.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Single.cs
index aad1e5b4d..d4253fe15 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Single.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.Single.cs
@@ -28,7 +28,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of float
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Divide"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((float*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray DivideSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.UInt16.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.UInt16.cs
deleted file mode 100644
index 28789f714..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.UInt16.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray DivideUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray DivideUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ushort
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Divide"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((ushort*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("ushort"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ushort*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.UInt32.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.UInt32.cs
deleted file mode 100644
index 6c323567c..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.UInt32.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray DivideUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray DivideUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of uint
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Divide"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((uint*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("uint"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((uint*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.UInt64.cs b/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.UInt64.cs
deleted file mode 100644
index 79f9ba0ac..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Divide/Default.Divide.UInt64.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray DivideUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray DivideUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ulong
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Divide"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((ulong*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("ulong"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Divide(*((ulong*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Divide(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Divide((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Boolean.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Boolean.cs
index 72c18cf0f..39d3925e6 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Boolean.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Boolean.cs
@@ -28,7 +28,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of bool
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Mod"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,6126 +238,24 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt16(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt16(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt16(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt16(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt16(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt32(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt32(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt32(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt64(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt64(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt64(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToChar(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToChar(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToChar(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToChar(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDouble(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToDouble(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToSingle(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToSingle(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDecimal(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt32(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6365,13 +263,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6379,7 +277,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6389,30 +287,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToInt32(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt64(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6420,13 +318,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6434,7 +332,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6444,30 +342,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToInt64(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToSingle(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6475,13 +373,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6489,7 +387,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6499,30 +397,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToSingle(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDouble(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6530,13 +428,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6544,7 +442,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6554,30 +452,48 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToDouble(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6585,13 +501,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6599,7 +515,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6609,30 +525,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6640,13 +556,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6654,7 +570,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6664,30 +580,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6695,13 +611,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6709,7 +625,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6719,30 +635,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6750,13 +666,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6764,7 +680,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6774,7 +690,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -6835,24 +751,24 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6860,13 +776,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6874,7 +790,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6884,7 +800,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -6894,15 +810,15 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Single: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((float*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7018,24 +934,24 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7043,13 +959,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7057,7 +973,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7067,30 +983,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7098,13 +1014,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7112,7 +1028,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7122,30 +1038,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((bool*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray ModBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Byte.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Byte.cs
index dc9ded0dd..7d1498921 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Byte.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Byte.cs
@@ -28,7 +28,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of byte
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Mod"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((byte*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray ModByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Char.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Char.cs
deleted file mode 100644
index d49f5633f..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Char.cs
+++ /dev/null
@@ -1,8259 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray ModChar(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of char
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Mod"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((char*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("char"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((char*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Decimal.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Decimal.cs
deleted file mode 100644
index 8c257c3af..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Decimal.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray ModDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray ModDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of decimal
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Mod"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((decimal*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("decimal"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((decimal*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Double.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Double.cs
index 6bad556d4..58c979d44 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Double.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Double.cs
@@ -28,7 +28,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of double
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Mod"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((double*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray ModDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int16.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int16.cs
deleted file mode 100644
index a9cc7dca7..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int16.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray ModInt16(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray ModInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of short
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Mod"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((short*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("short"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((short*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int32.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int32.cs
index 07c4bea05..111123288 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int32.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int32.cs
@@ -28,7 +28,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of int
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Mod"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((int*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray ModInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int64.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int64.cs
index 7b1965f6d..d7dbf2455 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int64.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Int64.cs
@@ -34,7 +34,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of long
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Mod"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -244,24 +244,24 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -269,13 +269,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -283,7 +283,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -293,30 +293,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -324,13 +324,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -338,7 +338,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -348,30 +348,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -379,13 +379,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -393,7 +393,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -403,30 +403,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -434,13 +434,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -448,7 +448,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -458,30 +458,48 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -489,13 +507,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -503,7 +521,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -513,30 +531,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -544,13 +562,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -558,7 +576,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -568,30 +586,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -599,13 +617,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -613,7 +631,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -623,30 +641,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -654,13 +672,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -668,7 +686,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -678,7 +696,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -739,24 +757,24 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -764,13 +782,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -778,7 +796,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -788,7 +806,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -798,15 +816,15 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -920,116 +938,6 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1087,24 +995,24 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1112,13 +1020,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1126,7 +1034,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1136,6022 +1044,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7159,13 +1075,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7173,7 +1089,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7183,30 +1099,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7214,13 +1130,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7228,7 +1144,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7238,30 +1154,48 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7269,13 +1203,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7283,7 +1217,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7293,30 +1227,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7324,13 +1258,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7338,7 +1272,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7348,30 +1282,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7379,13 +1313,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7393,7 +1327,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7403,30 +1337,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7434,13 +1368,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7448,7 +1382,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7458,7 +1392,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7519,24 +1453,24 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7544,13 +1478,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7558,7 +1492,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7568,7 +1502,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7578,15 +1512,15 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7702,24 +1636,24 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7727,13 +1661,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7741,7 +1675,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7751,30 +1685,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7782,13 +1716,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7796,7 +1730,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7806,30 +1740,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7837,13 +1771,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7851,7 +1785,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7861,30 +1795,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7892,13 +1826,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7906,7 +1840,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7916,30 +1850,48 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((long*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7947,13 +1899,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7961,7 +1913,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7971,30 +1923,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8002,13 +1954,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8016,7 +1968,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8026,30 +1978,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8057,13 +2009,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8071,7 +2023,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8081,30 +2033,30 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8112,13 +2064,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8126,7 +2078,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8136,7 +2088,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8197,24 +2149,24 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8222,13 +2174,13 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8236,7 +2188,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8246,7 +2198,7 @@ public unsafe NDArray ModInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Single.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Single.cs
index 0d82ac514..0db31d3d8 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Single.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.Single.cs
@@ -28,7 +28,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of float
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Mod"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((float*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray ModSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.UInt16.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.UInt16.cs
deleted file mode 100644
index ec0274b78..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.UInt16.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray ModUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray ModUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ushort
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Mod"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((ushort*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("ushort"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ushort*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.UInt32.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.UInt32.cs
deleted file mode 100644
index a144b8bf5..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.UInt32.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray ModUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray ModUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of uint
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Mod"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((uint*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("uint"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((uint*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.UInt64.cs b/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.UInt64.cs
deleted file mode 100644
index 8af27fca1..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Mod/Default.Mod.UInt64.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray ModUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray ModUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ulong
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Mod"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((ulong*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("ulong"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Mod(*((ulong*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Mod(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Mod((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Boolean.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Boolean.cs
index d35c36fb1..1da63c696 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Boolean.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Boolean.cs
@@ -28,7 +28,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of bool
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Multiply"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,6126 +238,24 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt16(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt16(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt16(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt16(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt16(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt32(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt32(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt32(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt64(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt64(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt64(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToChar(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToChar(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToChar(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToChar(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDouble(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToDouble(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToSingle(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToSingle(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDecimal(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt32(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6365,13 +263,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6379,7 +277,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6389,30 +287,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToInt32(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt64(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6420,13 +318,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6434,7 +332,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6444,30 +342,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToInt64(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToSingle(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6475,13 +373,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6489,7 +387,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6499,30 +397,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToSingle(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDouble(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6530,13 +428,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6544,7 +442,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6554,30 +452,48 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToDouble(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6585,13 +501,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6599,7 +515,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6609,30 +525,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6640,13 +556,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6654,7 +570,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6664,30 +580,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6695,13 +611,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6709,7 +625,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6719,30 +635,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6750,13 +666,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6764,7 +680,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6774,7 +690,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -6835,24 +751,24 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6860,13 +776,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6874,7 +790,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6884,7 +800,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -6894,15 +810,15 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Single: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((float*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7018,24 +934,24 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7043,13 +959,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7057,7 +973,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7067,30 +983,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7098,13 +1014,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7112,7 +1028,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7122,30 +1038,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((bool*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Byte.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Byte.cs
index 54055cfdd..d3685787a 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Byte.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Byte.cs
@@ -28,7 +28,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of byte
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Multiply"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((byte*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray MultiplyByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Char.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Char.cs
deleted file mode 100644
index f9a88897e..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Char.cs
+++ /dev/null
@@ -1,8259 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray MultiplyChar(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of char
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Multiply"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((char*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("char"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((char*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Decimal.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Decimal.cs
deleted file mode 100644
index 6d380237f..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Decimal.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray MultiplyDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray MultiplyDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of decimal
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Multiply"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((decimal*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("decimal"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((decimal*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Double.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Double.cs
index ddd0455fb..d59b96f47 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Double.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Double.cs
@@ -28,7 +28,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of double
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Multiply"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((double*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray MultiplyDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int16.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int16.cs
deleted file mode 100644
index 6f8b24444..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int16.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray MultiplyInt16(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray MultiplyInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of short
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Multiply"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((short*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("short"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((short*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int32.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int32.cs
index 5ab0e8ee9..91bf562b4 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int32.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int32.cs
@@ -28,7 +28,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of int
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Multiply"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((int*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray MultiplyInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int64.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int64.cs
index 8c5b2bdef..898913b5c 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int64.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Int64.cs
@@ -34,7 +34,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of long
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Multiply"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -244,24 +244,24 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -269,13 +269,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -283,7 +283,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -293,30 +293,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -324,13 +324,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -338,7 +338,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -348,30 +348,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -379,13 +379,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -393,7 +393,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -403,30 +403,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -434,13 +434,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -448,7 +448,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -458,30 +458,48 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -489,13 +507,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -503,7 +521,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -513,30 +531,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -544,13 +562,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -558,7 +576,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -568,30 +586,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -599,13 +617,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -613,7 +631,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -623,30 +641,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -654,13 +672,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -668,7 +686,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -678,7 +696,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -739,24 +757,24 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -764,13 +782,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -778,7 +796,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -788,7 +806,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -798,15 +816,15 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -920,116 +938,6 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1087,24 +995,24 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1112,13 +1020,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1126,7 +1034,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1136,6022 +1044,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7159,13 +1075,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7173,7 +1089,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7183,30 +1099,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7214,13 +1130,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7228,7 +1144,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7238,30 +1154,48 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7269,13 +1203,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7283,7 +1217,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7293,30 +1227,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7324,13 +1258,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7338,7 +1272,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7348,30 +1282,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7379,13 +1313,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7393,7 +1327,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7403,30 +1337,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7434,13 +1368,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7448,7 +1382,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7458,7 +1392,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7519,24 +1453,24 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7544,13 +1478,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7558,7 +1492,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7568,7 +1502,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7578,15 +1512,15 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7702,24 +1636,24 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7727,13 +1661,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7741,7 +1675,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7751,30 +1685,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7782,13 +1716,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7796,7 +1730,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7806,30 +1740,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7837,13 +1771,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7851,7 +1785,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7861,30 +1795,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7892,13 +1826,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7906,7 +1840,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7916,30 +1850,48 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((long*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7947,13 +1899,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7961,7 +1913,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7971,30 +1923,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8002,13 +1954,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8016,7 +1968,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8026,30 +1978,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8057,13 +2009,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8071,7 +2023,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8081,30 +2033,30 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8112,13 +2064,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8126,7 +2078,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8136,7 +2088,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8197,24 +2149,24 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8222,13 +2174,13 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8236,7 +2188,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8246,7 +2198,7 @@ public unsafe NDArray MultiplyInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Single.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Single.cs
index 0f162ae2b..f5f512631 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Single.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.Single.cs
@@ -28,7 +28,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of float
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Multiply"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((float*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray MultiplySingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.UInt16.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.UInt16.cs
deleted file mode 100644
index 63d891ca8..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.UInt16.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray MultiplyUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray MultiplyUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ushort
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Multiply"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((ushort*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("ushort"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ushort*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.UInt32.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.UInt32.cs
deleted file mode 100644
index 1bba12a82..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.UInt32.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray MultiplyUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray MultiplyUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of uint
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Multiply"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((uint*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("uint"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((uint*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.UInt64.cs b/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.UInt64.cs
deleted file mode 100644
index 89f161843..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Multiply/Default.Multiply.UInt64.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray MultiplyUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray MultiplyUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ulong
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Multiply"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((ulong*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("ulong"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Multiply(*((ulong*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Multiply(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Multiply((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.AMax.cs b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.AMax.cs
index f0a678059..66d9ca25e 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.AMax.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.AMax.cs
@@ -62,7 +62,7 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
             var iterIndex = iterRet.Index;
             var slices = iterAxis.Slices;
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -114,43 +114,13 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                byte max = moveNext();
+                                byte max = (byte)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (byte) Math.Max((byte)moveNext(), max);
 
                                 ret.SetByte(Converts.ToByte(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int32: 
                         {
@@ -159,28 +129,13 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int max = moveNext();
+                                int max = (int)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (int) Math.Max((int)moveNext(), max);
 
                                 ret.SetInt32(Converts.ToInt32(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int64: 
                         {
@@ -189,58 +144,13 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long max = moveNext();
+                                long max = (long)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (long) Math.Max((long)moveNext(), max);
 
                                 ret.SetInt64(Converts.ToInt64(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char max = (char)moveNext();
-                                while (hasNext())
-                                    max = (char) Math.Max((char)moveNext(), max);
-
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Single: 
                         {
@@ -249,26 +159,26 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                float max = moveNext();
+                                float max = (float)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (float) Math.Max((float)moveNext(), max);
 
                                 ret.SetSingle(Converts.ToSingle(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal max = moveNext();
+                                double max = (double)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (double) Math.Max((double)moveNext(), max);
 
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
@@ -277,7 +187,7 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
 		            }
                     break;
                 }
-			    case NPTypeCode.Int16: 
+			    case NPTypeCode.Int32: 
                 {
                     switch (ret.GetTypeCode)
 		            {
@@ -285,164 +195,74 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 byte max = (byte)moveNext();
                                 while (hasNext())
-                                    max = Math.Max((byte)moveNext(), max);
+                                    max = (byte) Math.Max((byte)moveNext(), max);
 
                                 ret.SetByte(Converts.ToByte(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort max = (ushort)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ushort)moveNext(), max);
-
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int max = moveNext();
+                                int max = (int)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (int) Math.Max((int)moveNext(), max);
 
                                 ret.SetInt32(Converts.ToInt32(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint max = (uint)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((uint)moveNext(), max);
-
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long max = moveNext();
+                                long max = (long)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (long) Math.Max((long)moveNext(), max);
 
                                 ret.SetInt64(Converts.ToInt64(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong max = (ulong)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ulong)moveNext(), max);
-
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char max = (char)moveNext();
-                                while (hasNext())
-                                    max = (char) Math.Max((char)moveNext(), max);
-
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                float max = moveNext();
+                                float max = (float)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (float) Math.Max((float)moveNext(), max);
 
                                 ret.SetSingle(Converts.ToSingle(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal max = moveNext();
+                                double max = (double)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (double) Math.Max((double)moveNext(), max);
 
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
@@ -451,7 +271,7 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
 		            }
                     break;
                 }
-			    case NPTypeCode.UInt16: 
+			    case NPTypeCode.Int64: 
                 {
                     switch (ret.GetTypeCode)
 		            {
@@ -459,134 +279,128 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 byte max = (byte)moveNext();
                                 while (hasNext())
-                                    max = Math.Max((byte)moveNext(), max);
+                                    max = (byte) Math.Max((byte)moveNext(), max);
 
                                 ret.SetByte(Converts.ToByte(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = (short)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((short)moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ushort max = moveNext();
+                                int max = (int)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (int) Math.Max((int)moveNext(), max);
 
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int max = moveNext();
+                                long max = (long)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (long) Math.Max((long)moveNext(), max);
 
-                                ret.SetInt32(Converts.ToInt32(max), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint max = moveNext();
+                                float max = (float)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (float) Math.Max((float)moveNext(), max);
 
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long max = moveNext();
+                                double max = (double)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (double) Math.Max((double)moveNext(), max);
 
-                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt64: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (ret.GetTypeCode)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ulong max = moveNext();
+                                byte max = (byte)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (byte) Math.Max((byte)moveNext(), max);
 
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
+                                ret.SetByte(Converts.ToByte(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                char max = (char)moveNext();
+                                int max = (int)moveNext();
                                 while (hasNext())
-                                    max = (char) Math.Max((char)moveNext(), max);
+                                    max = (int) Math.Max((int)moveNext(), max);
 
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Double: 
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                double max = moveNext();
+                                long max = (long)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (long) Math.Max((long)moveNext(), max);
 
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
@@ -594,29 +408,29 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                float max = moveNext();
+                                float max = (float)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (float) Math.Max((float)moveNext(), max);
 
                                 ret.SetSingle(Converts.ToSingle(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal max = moveNext();
+                                double max = (double)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (double) Math.Max((double)moveNext(), max);
 
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
@@ -625,7 +439,7 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
 		            }
                     break;
                 }
-			    case NPTypeCode.Int32: 
+			    case NPTypeCode.Double: 
                 {
                     switch (ret.GetTypeCode)
 		            {
@@ -633,2614 +447,328 @@ public override NDArray ReduceAMax(NDArray arr, int? axis_, bool keepdims = fals
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 byte max = (byte)moveNext();
                                 while (hasNext())
-                                    max = Math.Max((byte)moveNext(), max);
+                                    max = (byte) Math.Max((byte)moveNext(), max);
 
                                 ret.SetByte(Converts.ToByte(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = (short)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((short)moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort max = (ushort)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ushort)moveNext(), max);
-
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int max = moveNext();
+                                int max = (int)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (int) Math.Max((int)moveNext(), max);
 
                                 ret.SetInt32(Converts.ToInt32(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint max = (uint)moveNext();
+                                long max = (long)moveNext();
                                 while (hasNext())
-                                    max = Math.Max((uint)moveNext(), max);
+                                    max = (long) Math.Max((long)moveNext(), max);
 
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long max = moveNext();
+                                float max = (float)moveNext();
                                 while (hasNext())
-                                    max = Math.Max(moveNext(), max);
+                                    max = (float) Math.Max((float)moveNext(), max);
 
-                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt64: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ulong max = (ulong)moveNext();
+                                double max = (double)moveNext();
                                 while (hasNext())
-                                    max = Math.Max((ulong)moveNext(), max);
+                                    max = (double) Math.Max((double)moveNext(), max);
 
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char max = (char)moveNext();
-                                while (hasNext())
-                                    max = (char) Math.Max((char)moveNext(), max);
-
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetSingle(Converts.ToSingle(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt32: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte max = (byte)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((byte)moveNext(), max);
-
-                                ret.SetByte(Converts.ToByte(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = (short)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((short)moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort max = (ushort)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ushort)moveNext(), max);
-
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int max = (int)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((int)moveNext(), max);
-
-                                ret.SetInt32(Converts.ToInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char max = (char)moveNext();
-                                while (hasNext())
-                                    max = (char) Math.Max((char)moveNext(), max);
-
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetSingle(Converts.ToSingle(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int64: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte max = (byte)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((byte)moveNext(), max);
-
-                                ret.SetByte(Converts.ToByte(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = (short)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((short)moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort max = (ushort)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ushort)moveNext(), max);
-
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int max = (int)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((int)moveNext(), max);
-
-                                ret.SetInt32(Converts.ToInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint max = (uint)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((uint)moveNext(), max);
-
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong max = (ulong)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ulong)moveNext(), max);
-
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char max = (char)moveNext();
-                                while (hasNext())
-                                    max = (char) Math.Max((char)moveNext(), max);
-
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetSingle(Converts.ToSingle(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt64: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte max = (byte)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((byte)moveNext(), max);
-
-                                ret.SetByte(Converts.ToByte(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = (short)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((short)moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort max = (ushort)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ushort)moveNext(), max);
-
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int max = (int)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((int)moveNext(), max);
-
-                                ret.SetInt32(Converts.ToInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint max = (uint)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((uint)moveNext(), max);
-
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long max = (long)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((long)moveNext(), max);
-
-                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char max = (char)moveNext();
-                                while (hasNext())
-                                    max = (char) Math.Max((char)moveNext(), max);
-
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetSingle(Converts.ToSingle(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Char: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte max = (byte)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((byte)moveNext(), max);
-
-                                ret.SetByte(Converts.ToByte(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = (short)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((short)moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetInt32(Converts.ToInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char max = moveNext();
-                                while (hasNext())
-                                    max = (char) Math.Max(moveNext(), max);
-
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetSingle(Converts.ToSingle(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Double: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte max = (byte)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((byte)moveNext(), max);
-
-                                ret.SetByte(Converts.ToByte(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = (short)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((short)moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort max = (ushort)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ushort)moveNext(), max);
-
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int max = (int)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((int)moveNext(), max);
-
-                                ret.SetInt32(Converts.ToInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint max = (uint)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((uint)moveNext(), max);
-
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long max = (long)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((long)moveNext(), max);
-
-                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong max = (ulong)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ulong)moveNext(), max);
-
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char max = (char)moveNext();
-                                while (hasNext())
-                                    max = (char) Math.Max((char)moveNext(), max);
-
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float max = (float)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((float)moveNext(), max);
-
-                                ret.SetSingle(Converts.ToSingle(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal max = (decimal)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((decimal)moveNext(), max);
-
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Single: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte max = (byte)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((byte)moveNext(), max);
-
-                                ret.SetByte(Converts.ToByte(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = (short)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((short)moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort max = (ushort)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ushort)moveNext(), max);
-
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int max = (int)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((int)moveNext(), max);
-
-                                ret.SetInt32(Converts.ToInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint max = (uint)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((uint)moveNext(), max);
-
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long max = (long)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((long)moveNext(), max);
-
-                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong max = (ulong)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ulong)moveNext(), max);
-
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char max = (char)moveNext();
-                                while (hasNext())
-                                    max = (char) Math.Max((char)moveNext(), max);
-
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetSingle(Converts.ToSingle(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal max = (decimal)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((decimal)moveNext(), max);
-
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Decimal: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte max = (byte)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((byte)moveNext(), max);
-
-                                ret.SetByte(Converts.ToByte(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short max = (short)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((short)moveNext(), max);
-
-                                ret.SetInt16(Converts.ToInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort max = (ushort)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ushort)moveNext(), max);
-
-                                ret.SetUInt16(Converts.ToUInt16(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int max = (int)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((int)moveNext(), max);
-
-                                ret.SetInt32(Converts.ToInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint max = (uint)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((uint)moveNext(), max);
-
-                                ret.SetUInt32(Converts.ToUInt32(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long max = (long)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((long)moveNext(), max);
-
-                                ret.SetInt64(Converts.ToInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong max = (ulong)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((ulong)moveNext(), max);
-
-                                ret.SetUInt64(Converts.ToUInt64(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char max = (char)moveNext();
-                                while (hasNext())
-                                    max = (char) Math.Max((char)moveNext(), max);
-
-                                ret.SetChar(Converts.ToChar(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double max = (double)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((double)moveNext(), max);
-
-                                ret.SetDouble(Converts.ToDouble(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float max = (float)moveNext();
-                                while (hasNext())
-                                    max = Math.Max((float)moveNext(), max);
-
-                                ret.SetSingle(Converts.ToSingle(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal max = moveNext();
-                                while (hasNext())
-                                    max = Math.Max(moveNext(), max);
-
-                                ret.SetDecimal(Converts.ToDecimal(max), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#endif
-
-            if (keepdims)
-                ret.Storage.ExpandDimension(axis);
-
-            return ret;
-        }
-
-        public T AMaxElementwise<T>(NDArray arr, NPTypeCode? typeCode) where T : unmanaged
-        {
-            return (T)Converts.ChangeType(amax_elementwise(arr, typeCode), InfoOf<T>.NPTypeCode);
-        }
-
-        protected object amax_elementwise(NDArray arr, NPTypeCode? typeCode)
-        {
-            if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
-                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
-
-            var retType = typeCode ?? arr.GetTypeCode;
-#if _REGEN
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    %foreach supported_numericals,supported_numericals_lowercase%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_defaultvals%
-			            case NPTypeCode.#101: 
-                        {
-                            var iter = arr.AsIterator<#2>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            |#102 max = (#102)moveNext();
-                            while (hasNext())
-                                max = (#102) Math.Max((#102)moveNext(), max);
-
-                            return Converts.To#101(max);
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    %
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#else
-
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    case NPTypeCode.Byte: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt16(max);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt32(max);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = (char)moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max((char)moveNext(), max);
-
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDouble(max);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToSingle(max);
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDecimal(max);
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int16: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte max = (byte)moveNext();
-                            while (hasNext())
-                                max = Math.Max((byte)moveNext(), max);
-
-                            return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = (ushort)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ushort)moveNext(), max);
-
-                            return Converts.ToUInt16(max);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = (uint)moveNext();
-                            while (hasNext())
-                                max = Math.Max((uint)moveNext(), max);
-
-                            return Converts.ToUInt32(max);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = (ulong)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ulong)moveNext(), max);
-
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = (char)moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max((char)moveNext(), max);
-
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDouble(max);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToSingle(max);
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDecimal(max);
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt16: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte max = (byte)moveNext();
-                            while (hasNext())
-                                max = Math.Max((byte)moveNext(), max);
-
-                            return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = (short)moveNext();
-                            while (hasNext())
-                                max = Math.Max((short)moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt16(max);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt32(max);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = (char)moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max((char)moveNext(), max);
-
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDouble(max);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToSingle(max);
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDecimal(max);
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int32: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte max = (byte)moveNext();
-                            while (hasNext())
-                                max = Math.Max((byte)moveNext(), max);
-
-                            return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = (short)moveNext();
-                            while (hasNext())
-                                max = Math.Max((short)moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = (ushort)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ushort)moveNext(), max);
-
-                            return Converts.ToUInt16(max);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = (uint)moveNext();
-                            while (hasNext())
-                                max = Math.Max((uint)moveNext(), max);
-
-                            return Converts.ToUInt32(max);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = (ulong)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ulong)moveNext(), max);
-
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = (char)moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max((char)moveNext(), max);
-
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDouble(max);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToSingle(max);
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDecimal(max);
                         }
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.UInt32: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte max = (byte)moveNext();
-                            while (hasNext())
-                                max = Math.Max((byte)moveNext(), max);
-
-                            return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = (short)moveNext();
-                            while (hasNext())
-                                max = Math.Max((short)moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = (ushort)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ushort)moveNext(), max);
-
-                            return Converts.ToUInt16(max);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int max = (int)moveNext();
-                            while (hasNext())
-                                max = Math.Max((int)moveNext(), max);
-
-                            return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt32(max);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#endif
 
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = (char)moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max((char)moveNext(), max);
+            if (keepdims)
+                ret.Storage.ExpandDimension(axis);
 
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
+            return ret;
+        }
 
-                            return Converts.ToDouble(max);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
+        public T AMaxElementwise<T>(NDArray arr, NPTypeCode? typeCode) where T : unmanaged
+        {
+            return (T)Converts.ChangeType(amax_elementwise(arr, typeCode), InfoOf<T>.NPTypeCode);
+        }
 
-                            return Converts.ToSingle(max);
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
+        protected object amax_elementwise(NDArray arr, NPTypeCode? typeCode)
+        {
+            if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
+                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
 
-                            return Converts.ToDecimal(max);
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int64: 
+            var retType = typeCode ?? arr.GetTypeCode;
+#if _REGEN1
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    %foreach supported_numericals,supported_numericals_lowercase%
+			    case NPTypeCode.#1: 
                 {
                     switch (retType)
 		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte max = (byte)moveNext();
-                            while (hasNext())
-                                max = Math.Max((byte)moveNext(), max);
-
-                            return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = (short)moveNext();
-                            while (hasNext())
-                                max = Math.Max((short)moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = (ushort)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ushort)moveNext(), max);
-
-                            return Converts.ToUInt16(max);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int max = (int)moveNext();
-                            while (hasNext())
-                                max = Math.Max((int)moveNext(), max);
-
-                            return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = (uint)moveNext();
-                            while (hasNext())
-                                max = Math.Max((uint)moveNext(), max);
-
-                            return Converts.ToUInt32(max);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = (ulong)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ulong)moveNext(), max);
-
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = (char)moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max((char)moveNext(), max);
-
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDouble(max);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToSingle(max);
-                        }
-			            case NPTypeCode.Decimal: 
+			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_defaultvals%
+			            case NPTypeCode.#101: 
                         {
-                            var iter = arr.AsIterator<long>();
+                            var iter = arr.AsIterator<#2>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal max = moveNext();
+                            |#102 max = (#102)moveNext();
                             while (hasNext())
-                                max = Math.Max(moveNext(), max);
+                                max = (#102) Math.Max((#102)moveNext(), max);
 
-                            return Converts.ToDecimal(max);
+                            return Converts.To#101(max);
                         }
+			            %
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.UInt64: 
+			    %
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#else
+
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    case NPTypeCode.Byte: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<ulong>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte max = (byte)moveNext();
                             while (hasNext())
-                                max = Math.Max((byte)moveNext(), max);
+                                max = (byte) Math.Max((byte)moveNext(), max);
 
                             return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = (short)moveNext();
-                            while (hasNext())
-                                max = Math.Max((short)moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = (ushort)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ushort)moveNext(), max);
-
-                            return Converts.ToUInt16(max);
                         }
 			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<ulong>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int max = (int)moveNext();
                             while (hasNext())
-                                max = Math.Max((int)moveNext(), max);
+                                max = (int) Math.Max((int)moveNext(), max);
 
                             return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = (uint)moveNext();
-                            while (hasNext())
-                                max = Math.Max((uint)moveNext(), max);
-
-                            return Converts.ToUInt32(max);
                         }
 			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<ulong>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             long max = (long)moveNext();
                             while (hasNext())
-                                max = Math.Max((long)moveNext(), max);
+                                max = (long) Math.Max((long)moveNext(), max);
 
                             return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = (char)moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max((char)moveNext(), max);
-
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDouble(max);
                         }
 			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<ulong>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            float max = moveNext();
+                            float max = (float)moveNext();
                             while (hasNext())
-                                max = Math.Max(moveNext(), max);
+                                max = (float) Math.Max((float)moveNext(), max);
 
                             return Converts.ToSingle(max);
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<ulong>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal max = moveNext();
+                            double max = (double)moveNext();
                             while (hasNext())
-                                max = Math.Max(moveNext(), max);
+                                max = (double) Math.Max((double)moveNext(), max);
 
-                            return Converts.ToDecimal(max);
+                            return Converts.ToDouble(max);
                         }
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.Char: 
+			    case NPTypeCode.Int32: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte max = (byte)moveNext();
                             while (hasNext())
-                                max = Math.Max((byte)moveNext(), max);
+                                max = (byte) Math.Max((byte)moveNext(), max);
 
                             return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = (short)moveNext();
-                            while (hasNext())
-                                max = Math.Max((short)moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt16(max);
                         }
 			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            int max = moveNext();
+                            int max = (int)moveNext();
                             while (hasNext())
-                                max = Math.Max(moveNext(), max);
+                                max = (int) Math.Max((int)moveNext(), max);
 
                             return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt32(max);
                         }
 			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            long max = moveNext();
+                            long max = (long)moveNext();
                             while (hasNext())
-                                max = Math.Max(moveNext(), max);
+                                max = (long) Math.Max((long)moveNext(), max);
 
                             return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max(moveNext(), max);
-
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDouble(max);
                         }
 			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            float max = moveNext();
+                            float max = (float)moveNext();
                             while (hasNext())
-                                max = Math.Max(moveNext(), max);
+                                max = (float) Math.Max((float)moveNext(), max);
 
                             return Converts.ToSingle(max);
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal max = moveNext();
+                            double max = (double)moveNext();
                             while (hasNext())
-                                max = Math.Max(moveNext(), max);
+                                max = (double) Math.Max((double)moveNext(), max);
 
-                            return Converts.ToDecimal(max);
+                            return Converts.ToDouble(max);
                         }
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.Double: 
+			    case NPTypeCode.Int64: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte max = (byte)moveNext();
                             while (hasNext())
-                                max = Math.Max((byte)moveNext(), max);
+                                max = (byte) Math.Max((byte)moveNext(), max);
 
                             return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = (short)moveNext();
-                            while (hasNext())
-                                max = Math.Max((short)moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = (ushort)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ushort)moveNext(), max);
-
-                            return Converts.ToUInt16(max);
                         }
 			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int max = (int)moveNext();
                             while (hasNext())
-                                max = Math.Max((int)moveNext(), max);
+                                max = (int) Math.Max((int)moveNext(), max);
 
                             return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = (uint)moveNext();
-                            while (hasNext())
-                                max = Math.Max((uint)moveNext(), max);
-
-                            return Converts.ToUInt32(max);
                         }
 			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             long max = (long)moveNext();
                             while (hasNext())
-                                max = Math.Max((long)moveNext(), max);
+                                max = (long) Math.Max((long)moveNext(), max);
 
                             return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = (ulong)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ulong)moveNext(), max);
-
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = (char)moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max((char)moveNext(), max);
-
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDouble(max);
                         }
 			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             float max = (float)moveNext();
                             while (hasNext())
-                                max = Math.Max((float)moveNext(), max);
+                                max = (float) Math.Max((float)moveNext(), max);
 
                             return Converts.ToSingle(max);
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal max = (decimal)moveNext();
+                            double max = (double)moveNext();
                             while (hasNext())
-                                max = Math.Max((decimal)moveNext(), max);
+                                max = (double) Math.Max((double)moveNext(), max);
 
-                            return Converts.ToDecimal(max);
+                            return Converts.ToDouble(max);
                         }
 			            default:
 				            throw new NotSupportedException();
@@ -3258,31 +786,9 @@ protected object amax_elementwise(NDArray arr, NPTypeCode? typeCode)
                             var hasNext = iter.HasNext;
                             byte max = (byte)moveNext();
                             while (hasNext())
-                                max = Math.Max((byte)moveNext(), max);
+                                max = (byte) Math.Max((byte)moveNext(), max);
 
                             return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = (short)moveNext();
-                            while (hasNext())
-                                max = Math.Max((short)moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = (ushort)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ushort)moveNext(), max);
-
-                            return Converts.ToUInt16(max);
                         }
 			            case NPTypeCode.Int32: 
                         {
@@ -3291,20 +797,9 @@ protected object amax_elementwise(NDArray arr, NPTypeCode? typeCode)
                             var hasNext = iter.HasNext;
                             int max = (int)moveNext();
                             while (hasNext())
-                                max = Math.Max((int)moveNext(), max);
+                                max = (int) Math.Max((int)moveNext(), max);
 
                             return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = (uint)moveNext();
-                            while (hasNext())
-                                max = Math.Max((uint)moveNext(), max);
-
-                            return Converts.ToUInt32(max);
                         }
 			            case NPTypeCode.Int64: 
                         {
@@ -3313,194 +808,95 @@ protected object amax_elementwise(NDArray arr, NPTypeCode? typeCode)
                             var hasNext = iter.HasNext;
                             long max = (long)moveNext();
                             while (hasNext())
-                                max = Math.Max((long)moveNext(), max);
+                                max = (long) Math.Max((long)moveNext(), max);
 
                             return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = (ulong)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ulong)moveNext(), max);
-
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = (char)moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max((char)moveNext(), max);
-
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = moveNext();
-                            while (hasNext())
-                                max = Math.Max(moveNext(), max);
-
-                            return Converts.ToDouble(max);
                         }
 			            case NPTypeCode.Single: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            float max = moveNext();
+                            float max = (float)moveNext();
                             while (hasNext())
-                                max = Math.Max(moveNext(), max);
+                                max = (float) Math.Max((float)moveNext(), max);
 
                             return Converts.ToSingle(max);
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal max = (decimal)moveNext();
+                            double max = (double)moveNext();
                             while (hasNext())
-                                max = Math.Max((decimal)moveNext(), max);
+                                max = (double) Math.Max((double)moveNext(), max);
 
-                            return Converts.ToDecimal(max);
+                            return Converts.ToDouble(max);
                         }
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.Decimal: 
+			    case NPTypeCode.Double: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte max = (byte)moveNext();
                             while (hasNext())
-                                max = Math.Max((byte)moveNext(), max);
+                                max = (byte) Math.Max((byte)moveNext(), max);
 
                             return Converts.ToByte(max);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short max = (short)moveNext();
-                            while (hasNext())
-                                max = Math.Max((short)moveNext(), max);
-
-                            return Converts.ToInt16(max);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort max = (ushort)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ushort)moveNext(), max);
-
-                            return Converts.ToUInt16(max);
                         }
 			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int max = (int)moveNext();
                             while (hasNext())
-                                max = Math.Max((int)moveNext(), max);
+                                max = (int) Math.Max((int)moveNext(), max);
 
                             return Converts.ToInt32(max);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint max = (uint)moveNext();
-                            while (hasNext())
-                                max = Math.Max((uint)moveNext(), max);
-
-                            return Converts.ToUInt32(max);
                         }
 			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             long max = (long)moveNext();
                             while (hasNext())
-                                max = Math.Max((long)moveNext(), max);
+                                max = (long) Math.Max((long)moveNext(), max);
 
                             return Converts.ToInt64(max);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong max = (ulong)moveNext();
-                            while (hasNext())
-                                max = Math.Max((ulong)moveNext(), max);
-
-                            return Converts.ToUInt64(max);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char max = (char)moveNext();
-                            while (hasNext())
-                                max = (char) Math.Max((char)moveNext(), max);
-
-                            return Converts.ToChar(max);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double max = (double)moveNext();
-                            while (hasNext())
-                                max = Math.Max((double)moveNext(), max);
-
-                            return Converts.ToDouble(max);
                         }
 			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             float max = (float)moveNext();
                             while (hasNext())
-                                max = Math.Max((float)moveNext(), max);
+                                max = (float) Math.Max((float)moveNext(), max);
 
                             return Converts.ToSingle(max);
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal max = moveNext();
+                            double max = (double)moveNext();
                             while (hasNext())
-                                max = Math.Max(moveNext(), max);
+                                max = (double) Math.Max((double)moveNext(), max);
 
-                            return Converts.ToDecimal(max);
+                            return Converts.ToDouble(max);
                         }
 			            default:
 				            throw new NotSupportedException();
diff --git a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.AMin.cs b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.AMin.cs
index ef89c0ba6..f21943dc8 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.AMin.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.AMin.cs
@@ -62,7 +62,7 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
             var iterIndex = iterRet.Index;
             var slices = iterAxis.Slices;
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -114,43 +114,13 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                byte min = moveNext();
+                                byte min = (byte)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (byte) Math.Min((byte)moveNext(), min);
 
                                 ret.SetByte(Converts.ToByte(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int32: 
                         {
@@ -159,28 +129,13 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int min = moveNext();
+                                int min = (int)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (int) Math.Min((int)moveNext(), min);
 
                                 ret.SetInt32(Converts.ToInt32(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int64: 
                         {
@@ -189,58 +144,13 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long min = moveNext();
+                                long min = (long)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (long) Math.Min((long)moveNext(), min);
 
                                 ret.SetInt64(Converts.ToInt64(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char min = (char)moveNext();
-                                while (hasNext())
-                                    min = (char) Math.Min((char)moveNext(), min);
-
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Single: 
                         {
@@ -249,26 +159,26 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                float min = moveNext();
+                                float min = (float)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (float) Math.Min((float)moveNext(), min);
 
                                 ret.SetSingle(Converts.ToSingle(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal min = moveNext();
+                                double min = (double)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (double) Math.Min((double)moveNext(), min);
 
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
@@ -277,7 +187,7 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
 		            }
                     break;
                 }
-			    case NPTypeCode.Int16: 
+			    case NPTypeCode.Int32: 
                 {
                     switch (ret.GetTypeCode)
 		            {
@@ -285,164 +195,74 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 byte min = (byte)moveNext();
                                 while (hasNext())
-                                    min = Math.Min((byte)moveNext(), min);
+                                    min = (byte) Math.Min((byte)moveNext(), min);
 
                                 ret.SetByte(Converts.ToByte(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort min = (ushort)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ushort)moveNext(), min);
-
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int min = moveNext();
+                                int min = (int)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (int) Math.Min((int)moveNext(), min);
 
                                 ret.SetInt32(Converts.ToInt32(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint min = (uint)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((uint)moveNext(), min);
-
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long min = moveNext();
+                                long min = (long)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (long) Math.Min((long)moveNext(), min);
 
                                 ret.SetInt64(Converts.ToInt64(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong min = (ulong)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ulong)moveNext(), min);
-
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char min = (char)moveNext();
-                                while (hasNext())
-                                    min = (char) Math.Min((char)moveNext(), min);
-
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                float min = moveNext();
+                                float min = (float)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (float) Math.Min((float)moveNext(), min);
 
                                 ret.SetSingle(Converts.ToSingle(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal min = moveNext();
+                                double min = (double)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (double) Math.Min((double)moveNext(), min);
 
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
@@ -451,7 +271,7 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
 		            }
                     break;
                 }
-			    case NPTypeCode.UInt16: 
+			    case NPTypeCode.Int64: 
                 {
                     switch (ret.GetTypeCode)
 		            {
@@ -459,134 +279,128 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 byte min = (byte)moveNext();
                                 while (hasNext())
-                                    min = Math.Min((byte)moveNext(), min);
+                                    min = (byte) Math.Min((byte)moveNext(), min);
 
                                 ret.SetByte(Converts.ToByte(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = (short)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((short)moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ushort min = moveNext();
+                                int min = (int)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (int) Math.Min((int)moveNext(), min);
 
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int min = moveNext();
+                                long min = (long)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (long) Math.Min((long)moveNext(), min);
 
-                                ret.SetInt32(Converts.ToInt32(min), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint min = moveNext();
+                                float min = (float)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (float) Math.Min((float)moveNext(), min);
 
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long min = moveNext();
+                                double min = (double)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (double) Math.Min((double)moveNext(), min);
 
-                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt64: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (ret.GetTypeCode)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ulong min = moveNext();
+                                byte min = (byte)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (byte) Math.Min((byte)moveNext(), min);
 
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
+                                ret.SetByte(Converts.ToByte(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                char min = (char)moveNext();
+                                int min = (int)moveNext();
                                 while (hasNext())
-                                    min = (char) Math.Min((char)moveNext(), min);
+                                    min = (int) Math.Min((int)moveNext(), min);
 
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Double: 
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                double min = moveNext();
+                                long min = (long)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (long) Math.Min((long)moveNext(), min);
 
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
@@ -594,29 +408,29 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                float min = moveNext();
+                                float min = (float)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (float) Math.Min((float)moveNext(), min);
 
                                 ret.SetSingle(Converts.ToSingle(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal min = moveNext();
+                                double min = (double)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (double) Math.Min((double)moveNext(), min);
 
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
@@ -625,7 +439,7 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
 		            }
                     break;
                 }
-			    case NPTypeCode.Int32: 
+			    case NPTypeCode.Double: 
                 {
                     switch (ret.GetTypeCode)
 		            {
@@ -633,2614 +447,328 @@ public override NDArray ReduceAMin(NDArray arr, int? axis_, bool keepdims = fals
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 byte min = (byte)moveNext();
                                 while (hasNext())
-                                    min = Math.Min((byte)moveNext(), min);
+                                    min = (byte) Math.Min((byte)moveNext(), min);
 
                                 ret.SetByte(Converts.ToByte(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = (short)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((short)moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort min = (ushort)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ushort)moveNext(), min);
-
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int min = moveNext();
+                                int min = (int)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (int) Math.Min((int)moveNext(), min);
 
                                 ret.SetInt32(Converts.ToInt32(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint min = (uint)moveNext();
+                                long min = (long)moveNext();
                                 while (hasNext())
-                                    min = Math.Min((uint)moveNext(), min);
+                                    min = (long) Math.Min((long)moveNext(), min);
 
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long min = moveNext();
+                                float min = (float)moveNext();
                                 while (hasNext())
-                                    min = Math.Min(moveNext(), min);
+                                    min = (float) Math.Min((float)moveNext(), min);
 
-                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt64: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ulong min = (ulong)moveNext();
+                                double min = (double)moveNext();
                                 while (hasNext())
-                                    min = Math.Min((ulong)moveNext(), min);
+                                    min = (double) Math.Min((double)moveNext(), min);
 
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char min = (char)moveNext();
-                                while (hasNext())
-                                    min = (char) Math.Min((char)moveNext(), min);
-
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetSingle(Converts.ToSingle(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt32: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte min = (byte)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((byte)moveNext(), min);
-
-                                ret.SetByte(Converts.ToByte(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = (short)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((short)moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort min = (ushort)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ushort)moveNext(), min);
-
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int min = (int)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((int)moveNext(), min);
-
-                                ret.SetInt32(Converts.ToInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char min = (char)moveNext();
-                                while (hasNext())
-                                    min = (char) Math.Min((char)moveNext(), min);
-
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetSingle(Converts.ToSingle(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int64: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte min = (byte)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((byte)moveNext(), min);
-
-                                ret.SetByte(Converts.ToByte(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = (short)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((short)moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort min = (ushort)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ushort)moveNext(), min);
-
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int min = (int)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((int)moveNext(), min);
-
-                                ret.SetInt32(Converts.ToInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint min = (uint)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((uint)moveNext(), min);
-
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong min = (ulong)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ulong)moveNext(), min);
-
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char min = (char)moveNext();
-                                while (hasNext())
-                                    min = (char) Math.Min((char)moveNext(), min);
-
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetSingle(Converts.ToSingle(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt64: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte min = (byte)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((byte)moveNext(), min);
-
-                                ret.SetByte(Converts.ToByte(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = (short)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((short)moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort min = (ushort)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ushort)moveNext(), min);
-
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int min = (int)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((int)moveNext(), min);
-
-                                ret.SetInt32(Converts.ToInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint min = (uint)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((uint)moveNext(), min);
-
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long min = (long)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((long)moveNext(), min);
-
-                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char min = (char)moveNext();
-                                while (hasNext())
-                                    min = (char) Math.Min((char)moveNext(), min);
-
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetSingle(Converts.ToSingle(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Char: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte min = (byte)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((byte)moveNext(), min);
-
-                                ret.SetByte(Converts.ToByte(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = (short)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((short)moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetInt32(Converts.ToInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char min = moveNext();
-                                while (hasNext())
-                                    min = (char) Math.Min(moveNext(), min);
-
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetSingle(Converts.ToSingle(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Double: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte min = (byte)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((byte)moveNext(), min);
-
-                                ret.SetByte(Converts.ToByte(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = (short)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((short)moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort min = (ushort)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ushort)moveNext(), min);
-
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int min = (int)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((int)moveNext(), min);
-
-                                ret.SetInt32(Converts.ToInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint min = (uint)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((uint)moveNext(), min);
-
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long min = (long)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((long)moveNext(), min);
-
-                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong min = (ulong)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ulong)moveNext(), min);
-
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char min = (char)moveNext();
-                                while (hasNext())
-                                    min = (char) Math.Min((char)moveNext(), min);
-
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float min = (float)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((float)moveNext(), min);
-
-                                ret.SetSingle(Converts.ToSingle(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal min = (decimal)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((decimal)moveNext(), min);
-
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Single: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte min = (byte)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((byte)moveNext(), min);
-
-                                ret.SetByte(Converts.ToByte(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = (short)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((short)moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort min = (ushort)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ushort)moveNext(), min);
-
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int min = (int)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((int)moveNext(), min);
-
-                                ret.SetInt32(Converts.ToInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint min = (uint)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((uint)moveNext(), min);
-
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long min = (long)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((long)moveNext(), min);
-
-                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong min = (ulong)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ulong)moveNext(), min);
-
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char min = (char)moveNext();
-                                while (hasNext())
-                                    min = (char) Math.Min((char)moveNext(), min);
-
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetSingle(Converts.ToSingle(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal min = (decimal)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((decimal)moveNext(), min);
-
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Decimal: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte min = (byte)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((byte)moveNext(), min);
-
-                                ret.SetByte(Converts.ToByte(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short min = (short)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((short)moveNext(), min);
-
-                                ret.SetInt16(Converts.ToInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort min = (ushort)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ushort)moveNext(), min);
-
-                                ret.SetUInt16(Converts.ToUInt16(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int min = (int)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((int)moveNext(), min);
-
-                                ret.SetInt32(Converts.ToInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint min = (uint)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((uint)moveNext(), min);
-
-                                ret.SetUInt32(Converts.ToUInt32(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long min = (long)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((long)moveNext(), min);
-
-                                ret.SetInt64(Converts.ToInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong min = (ulong)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((ulong)moveNext(), min);
-
-                                ret.SetUInt64(Converts.ToUInt64(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char min = (char)moveNext();
-                                while (hasNext())
-                                    min = (char) Math.Min((char)moveNext(), min);
-
-                                ret.SetChar(Converts.ToChar(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double min = (double)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((double)moveNext(), min);
-
-                                ret.SetDouble(Converts.ToDouble(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float min = (float)moveNext();
-                                while (hasNext())
-                                    min = Math.Min((float)moveNext(), min);
-
-                                ret.SetSingle(Converts.ToSingle(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal min = moveNext();
-                                while (hasNext())
-                                    min = Math.Min(moveNext(), min);
-
-                                ret.SetDecimal(Converts.ToDecimal(min), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#endif
-
-            if (keepdims)
-                ret.Storage.ExpandDimension(axis);
-
-            return ret;
-        }
-
-        public T AMinElementwise<T>(NDArray arr, NPTypeCode? typeCode) where T : unmanaged
-        {
-            return (T)Converts.ChangeType(amin_elementwise(arr, typeCode), InfoOf<T>.NPTypeCode);
-        }
-
-        protected object amin_elementwise(NDArray arr, NPTypeCode? typeCode)
-        {
-            if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
-                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
-
-            var retType = typeCode ?? arr.GetTypeCode;
-#if _REGEN
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    %foreach supported_numericals,supported_numericals_lowercase%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_defaultvals%
-			            case NPTypeCode.#101: 
-                        {
-                            var iter = arr.AsIterator<#2>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            |#102 min = (#102)moveNext();
-                            while (hasNext())
-                                min = (#102) Math.Min((#102)moveNext(), min);
-
-                            return Converts.To#101(min);
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    %
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#else
-
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    case NPTypeCode.Byte: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt16(min);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt32(min);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = (char)moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min((char)moveNext(), min);
-
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDouble(min);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToSingle(min);
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDecimal(min);
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int16: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte min = (byte)moveNext();
-                            while (hasNext())
-                                min = Math.Min((byte)moveNext(), min);
-
-                            return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = (ushort)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ushort)moveNext(), min);
-
-                            return Converts.ToUInt16(min);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = (uint)moveNext();
-                            while (hasNext())
-                                min = Math.Min((uint)moveNext(), min);
-
-                            return Converts.ToUInt32(min);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = (ulong)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ulong)moveNext(), min);
-
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = (char)moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min((char)moveNext(), min);
-
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDouble(min);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToSingle(min);
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDecimal(min);
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt16: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte min = (byte)moveNext();
-                            while (hasNext())
-                                min = Math.Min((byte)moveNext(), min);
-
-                            return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = (short)moveNext();
-                            while (hasNext())
-                                min = Math.Min((short)moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt16(min);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt32(min);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = (char)moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min((char)moveNext(), min);
-
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDouble(min);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToSingle(min);
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDecimal(min);
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int32: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte min = (byte)moveNext();
-                            while (hasNext())
-                                min = Math.Min((byte)moveNext(), min);
-
-                            return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = (short)moveNext();
-                            while (hasNext())
-                                min = Math.Min((short)moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = (ushort)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ushort)moveNext(), min);
-
-                            return Converts.ToUInt16(min);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = (uint)moveNext();
-                            while (hasNext())
-                                min = Math.Min((uint)moveNext(), min);
-
-                            return Converts.ToUInt32(min);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = (ulong)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ulong)moveNext(), min);
-
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = (char)moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min((char)moveNext(), min);
-
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDouble(min);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToSingle(min);
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDecimal(min);
                         }
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.UInt32: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte min = (byte)moveNext();
-                            while (hasNext())
-                                min = Math.Min((byte)moveNext(), min);
-
-                            return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = (short)moveNext();
-                            while (hasNext())
-                                min = Math.Min((short)moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = (ushort)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ushort)moveNext(), min);
-
-                            return Converts.ToUInt16(min);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int min = (int)moveNext();
-                            while (hasNext())
-                                min = Math.Min((int)moveNext(), min);
-
-                            return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt32(min);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#endif
 
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = (char)moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min((char)moveNext(), min);
+            if (keepdims)
+                ret.Storage.ExpandDimension(axis);
 
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
+            return ret;
+        }
 
-                            return Converts.ToDouble(min);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
+        public T AMinElementwise<T>(NDArray arr, NPTypeCode? typeCode) where T : unmanaged
+        {
+            return (T)Converts.ChangeType(amin_elementwise(arr, typeCode), InfoOf<T>.NPTypeCode);
+        }
 
-                            return Converts.ToSingle(min);
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
+        protected object amin_elementwise(NDArray arr, NPTypeCode? typeCode)
+        {
+            if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
+                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
 
-                            return Converts.ToDecimal(min);
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int64: 
+            var retType = typeCode ?? arr.GetTypeCode;
+#if _REGEN1
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    %foreach supported_numericals,supported_numericals_lowercase%
+			    case NPTypeCode.#1: 
                 {
                     switch (retType)
 		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte min = (byte)moveNext();
-                            while (hasNext())
-                                min = Math.Min((byte)moveNext(), min);
-
-                            return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = (short)moveNext();
-                            while (hasNext())
-                                min = Math.Min((short)moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = (ushort)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ushort)moveNext(), min);
-
-                            return Converts.ToUInt16(min);
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int min = (int)moveNext();
-                            while (hasNext())
-                                min = Math.Min((int)moveNext(), min);
-
-                            return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = (uint)moveNext();
-                            while (hasNext())
-                                min = Math.Min((uint)moveNext(), min);
-
-                            return Converts.ToUInt32(min);
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = (ulong)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ulong)moveNext(), min);
-
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = (char)moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min((char)moveNext(), min);
-
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDouble(min);
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToSingle(min);
-                        }
-			            case NPTypeCode.Decimal: 
+			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_defaultvals%
+			            case NPTypeCode.#101: 
                         {
-                            var iter = arr.AsIterator<long>();
+                            var iter = arr.AsIterator<#2>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal min = moveNext();
+                            |#102 min = (#102)moveNext();
                             while (hasNext())
-                                min = Math.Min(moveNext(), min);
+                                min = (#102) Math.Min((#102)moveNext(), min);
 
-                            return Converts.ToDecimal(min);
+                            return Converts.To#101(min);
                         }
+			            %
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.UInt64: 
+			    %
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#else
+
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    case NPTypeCode.Byte: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<ulong>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte min = (byte)moveNext();
                             while (hasNext())
-                                min = Math.Min((byte)moveNext(), min);
+                                min = (byte) Math.Min((byte)moveNext(), min);
 
                             return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = (short)moveNext();
-                            while (hasNext())
-                                min = Math.Min((short)moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = (ushort)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ushort)moveNext(), min);
-
-                            return Converts.ToUInt16(min);
                         }
 			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<ulong>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int min = (int)moveNext();
                             while (hasNext())
-                                min = Math.Min((int)moveNext(), min);
+                                min = (int) Math.Min((int)moveNext(), min);
 
                             return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = (uint)moveNext();
-                            while (hasNext())
-                                min = Math.Min((uint)moveNext(), min);
-
-                            return Converts.ToUInt32(min);
                         }
 			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<ulong>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             long min = (long)moveNext();
                             while (hasNext())
-                                min = Math.Min((long)moveNext(), min);
+                                min = (long) Math.Min((long)moveNext(), min);
 
                             return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = (char)moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min((char)moveNext(), min);
-
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDouble(min);
                         }
 			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<ulong>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            float min = moveNext();
+                            float min = (float)moveNext();
                             while (hasNext())
-                                min = Math.Min(moveNext(), min);
+                                min = (float) Math.Min((float)moveNext(), min);
 
                             return Converts.ToSingle(min);
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<ulong>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal min = moveNext();
+                            double min = (double)moveNext();
                             while (hasNext())
-                                min = Math.Min(moveNext(), min);
+                                min = (double) Math.Min((double)moveNext(), min);
 
-                            return Converts.ToDecimal(min);
+                            return Converts.ToDouble(min);
                         }
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.Char: 
+			    case NPTypeCode.Int32: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte min = (byte)moveNext();
                             while (hasNext())
-                                min = Math.Min((byte)moveNext(), min);
+                                min = (byte) Math.Min((byte)moveNext(), min);
 
                             return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = (short)moveNext();
-                            while (hasNext())
-                                min = Math.Min((short)moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt16(min);
                         }
 			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            int min = moveNext();
+                            int min = (int)moveNext();
                             while (hasNext())
-                                min = Math.Min(moveNext(), min);
+                                min = (int) Math.Min((int)moveNext(), min);
 
                             return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt32(min);
                         }
 			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            long min = moveNext();
+                            long min = (long)moveNext();
                             while (hasNext())
-                                min = Math.Min(moveNext(), min);
+                                min = (long) Math.Min((long)moveNext(), min);
 
                             return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min(moveNext(), min);
-
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDouble(min);
                         }
 			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            float min = moveNext();
+                            float min = (float)moveNext();
                             while (hasNext())
-                                min = Math.Min(moveNext(), min);
+                                min = (float) Math.Min((float)moveNext(), min);
 
                             return Converts.ToSingle(min);
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal min = moveNext();
+                            double min = (double)moveNext();
                             while (hasNext())
-                                min = Math.Min(moveNext(), min);
+                                min = (double) Math.Min((double)moveNext(), min);
 
-                            return Converts.ToDecimal(min);
+                            return Converts.ToDouble(min);
                         }
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.Double: 
+			    case NPTypeCode.Int64: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte min = (byte)moveNext();
                             while (hasNext())
-                                min = Math.Min((byte)moveNext(), min);
+                                min = (byte) Math.Min((byte)moveNext(), min);
 
                             return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = (short)moveNext();
-                            while (hasNext())
-                                min = Math.Min((short)moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = (ushort)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ushort)moveNext(), min);
-
-                            return Converts.ToUInt16(min);
                         }
 			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int min = (int)moveNext();
                             while (hasNext())
-                                min = Math.Min((int)moveNext(), min);
+                                min = (int) Math.Min((int)moveNext(), min);
 
                             return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = (uint)moveNext();
-                            while (hasNext())
-                                min = Math.Min((uint)moveNext(), min);
-
-                            return Converts.ToUInt32(min);
                         }
 			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             long min = (long)moveNext();
                             while (hasNext())
-                                min = Math.Min((long)moveNext(), min);
+                                min = (long) Math.Min((long)moveNext(), min);
 
                             return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = (ulong)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ulong)moveNext(), min);
-
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = (char)moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min((char)moveNext(), min);
-
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDouble(min);
                         }
 			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             float min = (float)moveNext();
                             while (hasNext())
-                                min = Math.Min((float)moveNext(), min);
+                                min = (float) Math.Min((float)moveNext(), min);
 
                             return Converts.ToSingle(min);
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal min = (decimal)moveNext();
+                            double min = (double)moveNext();
                             while (hasNext())
-                                min = Math.Min((decimal)moveNext(), min);
+                                min = (double) Math.Min((double)moveNext(), min);
 
-                            return Converts.ToDecimal(min);
+                            return Converts.ToDouble(min);
                         }
 			            default:
 				            throw new NotSupportedException();
@@ -3258,31 +786,9 @@ protected object amin_elementwise(NDArray arr, NPTypeCode? typeCode)
                             var hasNext = iter.HasNext;
                             byte min = (byte)moveNext();
                             while (hasNext())
-                                min = Math.Min((byte)moveNext(), min);
+                                min = (byte) Math.Min((byte)moveNext(), min);
 
                             return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = (short)moveNext();
-                            while (hasNext())
-                                min = Math.Min((short)moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = (ushort)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ushort)moveNext(), min);
-
-                            return Converts.ToUInt16(min);
                         }
 			            case NPTypeCode.Int32: 
                         {
@@ -3291,20 +797,9 @@ protected object amin_elementwise(NDArray arr, NPTypeCode? typeCode)
                             var hasNext = iter.HasNext;
                             int min = (int)moveNext();
                             while (hasNext())
-                                min = Math.Min((int)moveNext(), min);
+                                min = (int) Math.Min((int)moveNext(), min);
 
                             return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = (uint)moveNext();
-                            while (hasNext())
-                                min = Math.Min((uint)moveNext(), min);
-
-                            return Converts.ToUInt32(min);
                         }
 			            case NPTypeCode.Int64: 
                         {
@@ -3313,194 +808,95 @@ protected object amin_elementwise(NDArray arr, NPTypeCode? typeCode)
                             var hasNext = iter.HasNext;
                             long min = (long)moveNext();
                             while (hasNext())
-                                min = Math.Min((long)moveNext(), min);
+                                min = (long) Math.Min((long)moveNext(), min);
 
                             return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = (ulong)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ulong)moveNext(), min);
-
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = (char)moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min((char)moveNext(), min);
-
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = moveNext();
-                            while (hasNext())
-                                min = Math.Min(moveNext(), min);
-
-                            return Converts.ToDouble(min);
                         }
 			            case NPTypeCode.Single: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            float min = moveNext();
+                            float min = (float)moveNext();
                             while (hasNext())
-                                min = Math.Min(moveNext(), min);
+                                min = (float) Math.Min((float)moveNext(), min);
 
                             return Converts.ToSingle(min);
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal min = (decimal)moveNext();
+                            double min = (double)moveNext();
                             while (hasNext())
-                                min = Math.Min((decimal)moveNext(), min);
+                                min = (double) Math.Min((double)moveNext(), min);
 
-                            return Converts.ToDecimal(min);
+                            return Converts.ToDouble(min);
                         }
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.Decimal: 
+			    case NPTypeCode.Double: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte min = (byte)moveNext();
                             while (hasNext())
-                                min = Math.Min((byte)moveNext(), min);
+                                min = (byte) Math.Min((byte)moveNext(), min);
 
                             return Converts.ToByte(min);
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short min = (short)moveNext();
-                            while (hasNext())
-                                min = Math.Min((short)moveNext(), min);
-
-                            return Converts.ToInt16(min);
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort min = (ushort)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ushort)moveNext(), min);
-
-                            return Converts.ToUInt16(min);
                         }
 			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int min = (int)moveNext();
                             while (hasNext())
-                                min = Math.Min((int)moveNext(), min);
+                                min = (int) Math.Min((int)moveNext(), min);
 
                             return Converts.ToInt32(min);
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint min = (uint)moveNext();
-                            while (hasNext())
-                                min = Math.Min((uint)moveNext(), min);
-
-                            return Converts.ToUInt32(min);
                         }
 			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             long min = (long)moveNext();
                             while (hasNext())
-                                min = Math.Min((long)moveNext(), min);
+                                min = (long) Math.Min((long)moveNext(), min);
 
                             return Converts.ToInt64(min);
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong min = (ulong)moveNext();
-                            while (hasNext())
-                                min = Math.Min((ulong)moveNext(), min);
-
-                            return Converts.ToUInt64(min);
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char min = (char)moveNext();
-                            while (hasNext())
-                                min = (char) Math.Min((char)moveNext(), min);
-
-                            return Converts.ToChar(min);
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double min = (double)moveNext();
-                            while (hasNext())
-                                min = Math.Min((double)moveNext(), min);
-
-                            return Converts.ToDouble(min);
                         }
 			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             float min = (float)moveNext();
                             while (hasNext())
-                                min = Math.Min((float)moveNext(), min);
+                                min = (float) Math.Min((float)moveNext(), min);
 
                             return Converts.ToSingle(min);
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal min = moveNext();
+                            double min = (double)moveNext();
                             while (hasNext())
-                                min = Math.Min(moveNext(), min);
+                                min = (double) Math.Min((double)moveNext(), min);
 
-                            return Converts.ToDecimal(min);
+                            return Converts.ToDouble(min);
                         }
 			            default:
 				            throw new NotSupportedException();
diff --git a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Add.cs b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Add.cs
index cdeb3ed49..4f688fe9a 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Add.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Add.cs
@@ -96,7 +96,7 @@ public override NDArray ReduceAdd(in NDArray arr, int? axis_, bool keepdims = fa
             var iterIndex = iterRet.Index;
             var slices = iterAxis.Slices;
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -135,14 +135,13 @@ public override NDArray ReduceAdd(in NDArray arr, int? axis_, bool keepdims = fa
 #else
 
             #region Compute
-
             switch (arr.GetTypeCode)
-            {
-                case NPTypeCode.Byte:
+		    {
+			    case NPTypeCode.Byte: 
                 {
                     switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
@@ -151,3813 +150,797 @@ public override NDArray ReduceAdd(in NDArray arr, int? axis_, bool keepdims = fa
                                 var hasNext = iter.HasNext;
                                 byte sum = default;
                                 while (hasNext())
-                                    sum += (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = default;
-                                while (hasNext())
-                                    sum += (short)moveNext();
+                                    sum += (byte) moveNext();
 
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
+                                ret.SetByte(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ushort sum = default;
+                                int sum = default;
                                 while (hasNext())
-                                    sum += (ushort)moveNext();
+                                    sum += (int) moveNext();
 
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
+                                ret.SetInt32(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = default;
+                                long sum = default;
                                 while (hasNext())
-                                    sum += (int)moveNext();
+                                    sum += (long) moveNext();
 
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
+                                ret.SetInt64(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = default;
+                                float sum = default;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (float) moveNext();
 
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
+                                ret.SetSingle(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var iter = arr[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long sum = default;
+                                double sum = default;
                                 while (hasNext())
-                                    sum += (long)moveNext();
+                                    sum += (double) moveNext();
 
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
+                                ret.SetDouble(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int32: 
+                {
+                    switch (ret.GetTypeCode)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<byte>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ulong sum = default;
+                                byte sum = default;
                                 while (hasNext())
-                                    sum += (ulong)moveNext();
+                                    sum += (byte) moveNext();
 
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
+                                ret.SetByte(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<byte>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                char sum = default;
+                                int sum = default;
                                 while (hasNext())
-                                    sum += (char)moveNext();
+                                    sum += (int) moveNext();
 
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
+                                ret.SetInt32(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<byte>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                double sum = default;
+                                long sum = default;
                                 while (hasNext())
-                                    sum += (double)moveNext();
+                                    sum += (long) moveNext();
 
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
+                                ret.SetInt64(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<byte>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 float sum = default;
                                 while (hasNext())
-                                    sum += (float)moveNext();
+                                    sum += (float) moveNext();
 
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
+                                ret.SetSingle(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<byte>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal sum = default;
+                                double sum = default;
                                 while (hasNext())
-                                    sum += (decimal)moveNext();
+                                    sum += (double) moveNext();
 
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
+                                ret.SetDouble(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Int16:
+			    case NPTypeCode.Int64: 
                 {
                     switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 byte sum = default;
                                 while (hasNext())
-                                    sum += (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = default;
-                                while (hasNext())
-                                    sum += (short)moveNext();
+                                    sum += (byte) moveNext();
 
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
+                                ret.SetByte(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ushort sum = default;
+                                int sum = default;
                                 while (hasNext())
-                                    sum += (ushort)moveNext();
+                                    sum += (int) moveNext();
 
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
+                                ret.SetInt32(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = default;
+                                long sum = default;
                                 while (hasNext())
-                                    sum += (int)moveNext();
+                                    sum += (long) moveNext();
 
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
+                                ret.SetInt64(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = default;
+                                float sum = default;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (float) moveNext();
 
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
+                                ret.SetSingle(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long sum = default;
+                                double sum = default;
                                 while (hasNext())
-                                    sum += (long)moveNext();
+                                    sum += (double) moveNext();
 
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
+                                ret.SetDouble(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (ret.GetTypeCode)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ulong sum = default;
+                                byte sum = default;
                                 while (hasNext())
-                                    sum += (ulong)moveNext();
+                                    sum += (byte) moveNext();
 
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
+                                ret.SetByte(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                char sum = default;
+                                int sum = default;
                                 while (hasNext())
-                                    sum += (char)moveNext();
+                                    sum += (int) moveNext();
 
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
+                                ret.SetInt32(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                double sum = default;
+                                long sum = default;
                                 while (hasNext())
-                                    sum += (double)moveNext();
+                                    sum += (long) moveNext();
 
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
+                                ret.SetInt64(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 float sum = default;
                                 while (hasNext())
-                                    sum += (float)moveNext();
+                                    sum += (float) moveNext();
 
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
+                                ret.SetSingle(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal sum = default;
+                                double sum = default;
                                 while (hasNext())
-                                    sum += (decimal)moveNext();
+                                    sum += (double) moveNext();
 
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
+                                ret.SetDouble(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.UInt16:
+			    case NPTypeCode.Double: 
                 {
                     switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 byte sum = default;
                                 while (hasNext())
-                                    sum += (byte)moveNext();
+                                    sum += (byte) moveNext();
 
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
+                                ret.SetByte(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int16:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                short sum = default;
+                                int sum = default;
                                 while (hasNext())
-                                    sum += (short)moveNext();
+                                    sum += (int) moveNext();
 
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
+                                ret.SetInt32(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ushort sum = default;
+                                long sum = default;
                                 while (hasNext())
-                                    sum += (ushort)moveNext();
+                                    sum += (long) moveNext();
 
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
+                                ret.SetInt64(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = default;
+                                float sum = default;
                                 while (hasNext())
-                                    sum += (int)moveNext();
+                                    sum += (float) moveNext();
 
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
+                                ret.SetSingle(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = default;
+                                double sum = default;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (double) moveNext();
 
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
+                                ret.SetDouble(sum, iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#endif
 
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = default;
-                                while (hasNext())
-                                    sum += (long)moveNext();
+            if (keepdims && @out is null)
+                ret.Storage.ExpandDimension(axis);
 
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
+            return ret;
+        }
 
-                            break;
-                        }
+        public T SumElementwise<T>(NDArray arr, NPTypeCode? typeCode) where T : unmanaged
+        {
+            return (T)Converts.ChangeType(sum_elementwise(arr, typeCode), InfoOf<T>.NPTypeCode);
+        }
 
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = default;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
+        protected object sum_elementwise(NDArray arr, NPTypeCode? typeCode)
+        {
+            if (arr.Shape.IsScalar || (arr.Shape.NDim == 1 && arr.Shape.size == 1))
+                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
 
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
+            var retType = typeCode ?? (arr.GetTypeCode.GetAccumulatingType());
+#if _REGEN1
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    %foreach supported_numericals,supported_numericals_lowercase%
+			    case NPTypeCode.#1: 
+                {
+                    switch (retType)
+		            {
+			            %foreach supported_numericals,supported_numericals_lowercase%
+			            case NPTypeCode.#101: 
+                        {
+                            var iter = arr.AsIterator<#2>();
+                            var moveNext = iter.MoveNext;
+                            var hasNext = iter.HasNext;
+                            |#102 sum = default;
+                            while (hasNext())
+                                sum += (#102) moveNext();
 
-                            break;
+                            return sum;
                         }
+			            %
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    %
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#else
 
-                        case NPTypeCode.Char:
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    case NPTypeCode.Byte: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = default;
-                                while (hasNext())
-                                    sum += (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
+                            var iter = arr.AsIterator<byte>();
+                            var moveNext = iter.MoveNext;
+                            var hasNext = iter.HasNext;
+                            byte sum = default;
+                            while (hasNext())
+                                sum += (byte) moveNext();
 
-                            break;
+                            return sum;
                         }
+			            case NPTypeCode.Int32: 
+                        {
+                            var iter = arr.AsIterator<byte>();
+                            var moveNext = iter.MoveNext;
+                            var hasNext = iter.HasNext;
+                            int sum = default;
+                            while (hasNext())
+                                sum += (int) moveNext();
 
-                        case NPTypeCode.Double:
+                            return sum;
+                        }
+			            case NPTypeCode.Int64: 
                         {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = default;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = default;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = default;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = default;
-                                while (hasNext())
-                                    sum += (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = default;
-                                while (hasNext())
-                                    sum += (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = default;
-                                while (hasNext())
-                                    sum += (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = default;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = default;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = default;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = default;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = default;
-                                while (hasNext())
-                                    sum += (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = default;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = default;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = default;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = default;
-                                while (hasNext())
-                                    sum += (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = default;
-                                while (hasNext())
-                                    sum += (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = default;
-                                while (hasNext())
-                                    sum += (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = default;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = default;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = default;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = default;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = default;
-                                while (hasNext())
-                                    sum += (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = default;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = default;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = default;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = default;
-                                while (hasNext())
-                                    sum += (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = default;
-                                while (hasNext())
-                                    sum += (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = default;
-                                while (hasNext())
-                                    sum += (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = default;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = default;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = default;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = default;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = default;
-                                while (hasNext())
-                                    sum += (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = default;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = default;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = default;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = default;
-                                while (hasNext())
-                                    sum += (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = default;
-                                while (hasNext())
-                                    sum += (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = default;
-                                while (hasNext())
-                                    sum += (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = default;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = default;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = default;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = default;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = default;
-                                while (hasNext())
-                                    sum += (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = default;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = default;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = default;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = default;
-                                while (hasNext())
-                                    sum += (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = default;
-                                while (hasNext())
-                                    sum += (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = default;
-                                while (hasNext())
-                                    sum += (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = default;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = default;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = default;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = default;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = default;
-                                while (hasNext())
-                                    sum += (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = default;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = default;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = default;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = default;
-                                while (hasNext())
-                                    sum += (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = default;
-                                while (hasNext())
-                                    sum += (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = default;
-                                while (hasNext())
-                                    sum += (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = default;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = default;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = default;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = default;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = default;
-                                while (hasNext())
-                                    sum += (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = default;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = default;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = default;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = default;
-                                while (hasNext())
-                                    sum += (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = default;
-                                while (hasNext())
-                                    sum += (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = default;
-                                while (hasNext())
-                                    sum += (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = default;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = default;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = default;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = default;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = default;
-                                while (hasNext())
-                                    sum += (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = default;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = default;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = default;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Decimal:
-                {
-                    switch (ret.GetTypeCode)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = default;
-                                while (hasNext())
-                                    sum += (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = default;
-                                while (hasNext())
-                                    sum += (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = default;
-                                while (hasNext())
-                                    sum += (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = default;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = default;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = default;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = default;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = default;
-                                while (hasNext())
-                                    sum += (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = default;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = default;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = default;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                default:
-                    throw new NotSupportedException();
-            }
-
-            #endregion
-
-#endif
-
-            if (keepdims && @out is null)
-                ret.Storage.ExpandDimension(axis);
-
-            return ret;
-        }
-
-        public T SumElementwise<T>(NDArray arr, NPTypeCode? typeCode) where T : unmanaged
-        {
-            return (T)Converts.ChangeType(sum_elementwise(arr, typeCode), InfoOf<T>.NPTypeCode);
-        }
-
-        protected object sum_elementwise(NDArray arr, NPTypeCode? typeCode)
-        {
-            if (arr.Shape.IsScalar || (arr.Shape.NDim == 1 && arr.Shape.size == 1))
-                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
-
-            var retType = typeCode ?? (arr.GetTypeCode.GetAccumulatingType());
-#if _REGEN
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    %foreach supported_numericals,supported_numericals_lowercase%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase%
-			            case NPTypeCode.#101: 
-                        {
-                            var iter = arr.AsIterator<#2>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            |#102 sum = default;
-                            while (hasNext())
-                                sum += (#102) moveNext();
-
-                            return sum;
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    %
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#else
-
-            #region Compute
-
-            switch (arr.GetTypeCode)
-            {
-                case NPTypeCode.Byte:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt16(sum);
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt16(sum);
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt32(sum);
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt32(sum);
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
-                            while (hasNext())
-                                sum += (Int64)moveNext();
-
-                            return Converts.ToInt64(sum);
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
-                            while (hasNext())
-                                sum += (UInt64)moveNext();
-
-                            return Converts.ToUInt64(sum);
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToChar(sum);
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Double sum = 0d;
-                            while (hasNext())
-                                sum += (Double)moveNext();
-
-                            return Converts.ToDouble(sum);
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Single sum = 0f;
-                            while (hasNext())
-                                sum += (Single)moveNext();
-
-                            return Converts.ToSingle(sum);
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
-                            while (hasNext())
-                                sum += (Decimal)moveNext();
-
-                            return Converts.ToDecimal(sum);
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt16(sum);
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt16(sum);
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt32(sum);
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt32(sum);
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
-                            while (hasNext())
-                                sum += (Int64)moveNext();
-
-                            return Converts.ToInt64(sum);
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
-                            while (hasNext())
-                                sum += (UInt64)moveNext();
-
-                            return Converts.ToUInt64(sum);
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToChar(sum);
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Double sum = 0d;
-                            while (hasNext())
-                                sum += (Double)moveNext();
-
-                            return Converts.ToDouble(sum);
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Single sum = 0f;
-                            while (hasNext())
-                                sum += (Single)moveNext();
-
-                            return Converts.ToSingle(sum);
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
-                            while (hasNext())
-                                sum += (Decimal)moveNext();
-
-                            return Converts.ToDecimal(sum);
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt16(sum);
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt16(sum);
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt32(sum);
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt32(sum);
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
-                            while (hasNext())
-                                sum += (Int64)moveNext();
-
-                            return Converts.ToInt64(sum);
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
-                            while (hasNext())
-                                sum += (UInt64)moveNext();
-
-                            return Converts.ToUInt64(sum);
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToChar(sum);
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Double sum = 0d;
-                            while (hasNext())
-                                sum += (Double)moveNext();
-
-                            return Converts.ToDouble(sum);
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Single sum = 0f;
-                            while (hasNext())
-                                sum += (Single)moveNext();
-
-                            return Converts.ToSingle(sum);
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
-                            while (hasNext())
-                                sum += (Decimal)moveNext();
-
-                            return Converts.ToDecimal(sum);
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt16(sum);
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt16(sum);
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt32(sum);
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt32(sum);
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
-                            while (hasNext())
-                                sum += (Int64)moveNext();
-
-                            return Converts.ToInt64(sum);
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
-                            while (hasNext())
-                                sum += (UInt64)moveNext();
-
-                            return Converts.ToUInt64(sum);
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToChar(sum);
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Double sum = 0d;
-                            while (hasNext())
-                                sum += (Double)moveNext();
-
-                            return Converts.ToDouble(sum);
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Single sum = 0f;
-                            while (hasNext())
-                                sum += (Single)moveNext();
-
-                            return Converts.ToSingle(sum);
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
-                            while (hasNext())
-                                sum += (Decimal)moveNext();
-
-                            return Converts.ToDecimal(sum);
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt16(sum);
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt16(sum);
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt32(sum);
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt32(sum);
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
-                            while (hasNext())
-                                sum += (Int64)moveNext();
-
-                            return Converts.ToInt64(sum);
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
-                            while (hasNext())
-                                sum += (UInt64)moveNext();
-
-                            return Converts.ToUInt64(sum);
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToChar(sum);
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Double sum = 0d;
-                            while (hasNext())
-                                sum += (Double)moveNext();
-
-                            return Converts.ToDouble(sum);
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Single sum = 0f;
-                            while (hasNext())
-                                sum += (Single)moveNext();
-
-                            return Converts.ToSingle(sum);
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
-                            while (hasNext())
-                                sum += (Decimal)moveNext();
-
-                            return Converts.ToDecimal(sum);
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt16(sum);
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt16(sum);
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt32(sum);
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt32(sum);
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
-                            while (hasNext())
-                                sum += (Int64)moveNext();
-
-                            return Converts.ToInt64(sum);
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
-                            while (hasNext())
-                                sum += (UInt64)moveNext();
-
-                            return Converts.ToUInt64(sum);
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToChar(sum);
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Double sum = 0d;
-                            while (hasNext())
-                                sum += (Double)moveNext();
-
-                            return Converts.ToDouble(sum);
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Single sum = 0f;
-                            while (hasNext())
-                                sum += (Single)moveNext();
-
-                            return Converts.ToSingle(sum);
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
-                            while (hasNext())
-                                sum += (Decimal)moveNext();
-
-                            return Converts.ToDecimal(sum);
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt16(sum);
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt16(sum);
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt32(sum);
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt32(sum);
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
-                            while (hasNext())
-                                sum += (Int64)moveNext();
-
-                            return Converts.ToInt64(sum);
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
-                            while (hasNext())
-                                sum += (UInt64)moveNext();
-
-                            return Converts.ToUInt64(sum);
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToChar(sum);
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Double sum = 0d;
-                            while (hasNext())
-                                sum += (Double)moveNext();
-
-                            return Converts.ToDouble(sum);
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Single sum = 0f;
-                            while (hasNext())
-                                sum += (Single)moveNext();
-
-                            return Converts.ToSingle(sum);
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
-                            while (hasNext())
-                                sum += (Decimal)moveNext();
-
-                            return Converts.ToDecimal(sum);
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt16(sum);
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt16(sum);
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt32(sum);
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt32(sum);
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
-                            while (hasNext())
-                                sum += (Int64)moveNext();
-
-                            return Converts.ToInt64(sum);
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
-                            while (hasNext())
-                                sum += (UInt64)moveNext();
-
-                            return Converts.ToUInt64(sum);
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToChar(sum);
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Double sum = 0d;
+                            long sum = default;
                             while (hasNext())
-                                sum += (Double)moveNext();
+                                sum += (long) moveNext();
 
-                            return Converts.ToDouble(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Single sum = 0f;
+                            float sum = default;
                             while (hasNext())
-                                sum += (Single)moveNext();
+                                sum += (float) moveNext();
 
-                            return Converts.ToSingle(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
+                            double sum = default;
                             while (hasNext())
-                                sum += (Decimal)moveNext();
+                                sum += (double) moveNext();
 
-                            return Converts.ToDecimal(sum);
+                            return sum;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Double:
+			    case NPTypeCode.Int32: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt16(sum);
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt16(sum);
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt32(sum);
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt32(sum);
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
-                            while (hasNext())
-                                sum += (Int64)moveNext();
-
-                            return Converts.ToInt64(sum);
-                        }
-
-                        case NPTypeCode.UInt64:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
+                            byte sum = default;
                             while (hasNext())
-                                sum += (UInt64)moveNext();
+                                sum += (byte) moveNext();
 
-                            return Converts.ToUInt64(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
+                            int sum = default;
                             while (hasNext())
-                                sum += (UInt32)moveNext();
+                                sum += (int) moveNext();
 
-                            return Converts.ToChar(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Double sum = 0d;
+                            long sum = default;
                             while (hasNext())
-                                sum += (Double)moveNext();
+                                sum += (long) moveNext();
 
-                            return Converts.ToDouble(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Single sum = 0f;
+                            float sum = default;
                             while (hasNext())
-                                sum += (Single)moveNext();
+                                sum += (float) moveNext();
 
-                            return Converts.ToSingle(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
+                            double sum = default;
                             while (hasNext())
-                                sum += (Decimal)moveNext();
+                                sum += (double) moveNext();
 
-                            return Converts.ToDecimal(sum);
+                            return sum;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Single:
+			    case NPTypeCode.Int64: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Int32 sum = 0;
+                            byte sum = default;
                             while (hasNext())
-                                sum += (Int32)moveNext();
+                                sum += (byte) moveNext();
 
-                            return Converts.ToInt16(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
+                            int sum = default;
                             while (hasNext())
-                                sum += (UInt32)moveNext();
+                                sum += (int) moveNext();
 
-                            return Converts.ToUInt16(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Int32 sum = 0;
+                            long sum = default;
                             while (hasNext())
-                                sum += (Int32)moveNext();
+                                sum += (long) moveNext();
 
-                            return Converts.ToInt32(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
+                            float sum = default;
                             while (hasNext())
-                                sum += (UInt32)moveNext();
+                                sum += (float) moveNext();
 
-                            return Converts.ToUInt32(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
+                            double sum = default;
                             while (hasNext())
-                                sum += (Int64)moveNext();
+                                sum += (double) moveNext();
 
-                            return Converts.ToInt64(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
+                            byte sum = default;
                             while (hasNext())
-                                sum += (UInt64)moveNext();
+                                sum += (byte) moveNext();
 
-                            return Converts.ToUInt64(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
+                            int sum = default;
                             while (hasNext())
-                                sum += (UInt32)moveNext();
+                                sum += (int) moveNext();
 
-                            return Converts.ToChar(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Double sum = 0d;
+                            long sum = default;
                             while (hasNext())
-                                sum += (Double)moveNext();
+                                sum += (long) moveNext();
 
-                            return Converts.ToDouble(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Single sum = 0f;
+                            float sum = default;
                             while (hasNext())
-                                sum += (Single)moveNext();
+                                sum += (float) moveNext();
 
-                            return Converts.ToSingle(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
+                            double sum = default;
                             while (hasNext())
-                                sum += (Decimal)moveNext();
+                                sum += (double) moveNext();
 
-                            return Converts.ToDecimal(sum);
+                            return sum;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Decimal:
+			    case NPTypeCode.Double: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToByte(sum);
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt16(sum);
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt16(sum);
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int32 sum = 0;
-                            while (hasNext())
-                                sum += (Int32)moveNext();
-
-                            return Converts.ToInt32(sum);
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            UInt32 sum = 0u;
-                            while (hasNext())
-                                sum += (UInt32)moveNext();
-
-                            return Converts.ToUInt32(sum);
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            Int64 sum = 0L;
-                            while (hasNext())
-                                sum += (Int64)moveNext();
-
-                            return Converts.ToInt64(sum);
-                        }
-
-                        case NPTypeCode.UInt64:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            UInt64 sum = 0UL;
+                            byte sum = default;
                             while (hasNext())
-                                sum += (UInt64)moveNext();
+                                sum += (byte) moveNext();
 
-                            return Converts.ToUInt64(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            UInt32 sum = '\0';
+                            int sum = default;
                             while (hasNext())
-                                sum += (UInt32)moveNext();
+                                sum += (int) moveNext();
 
-                            return Converts.ToChar(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Double sum = 0d;
+                            long sum = default;
                             while (hasNext())
-                                sum += (Double)moveNext();
+                                sum += (long) moveNext();
 
-                            return Converts.ToDouble(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Single sum = 0f;
+                            float sum = default;
                             while (hasNext())
-                                sum += (Single)moveNext();
+                                sum += (float) moveNext();
 
-                            return Converts.ToSingle(sum);
+                            return sum;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            Decimal sum = 0m;
+                            double sum = default;
                             while (hasNext())
-                                sum += (Decimal)moveNext();
+                                sum += (double) moveNext();
 
-                            return Converts.ToDecimal(sum);
+                            return sum;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                default:
-                    throw new NotSupportedException();
-            }
-
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
     }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.ArgMax.cs b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.ArgMax.cs
index 390cbc258..66553979d 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.ArgMax.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.ArgMax.cs
@@ -44,7 +44,7 @@ public override NDArray ReduceArgMax(NDArray arr, int? axis_)
             var iterIndex = iterRet.Index;
             var slices = iterAxis.Slices;
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -110,58 +110,6 @@ public override NDArray ReduceArgMax(NDArray arr, int? axis_)
                         ret.SetInt32(maxAt, iterIndex);
                     } while (iterAxis.Next() != null && iterRet.Next() != null);
                     break;
-                }
-			    case NPTypeCode.Int16: 
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<short>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        short max = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val > max)
-                            {
-                                max = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-                    break;
-                }
-			    case NPTypeCode.UInt16: 
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<ushort>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        ushort max = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val > max)
-                            {
-                                max = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-                    break;
                 }
 			    case NPTypeCode.Int32: 
                 {
@@ -188,32 +136,6 @@ public override NDArray ReduceArgMax(NDArray arr, int? axis_)
                         ret.SetInt32(maxAt, iterIndex);
                     } while (iterAxis.Next() != null && iterRet.Next() != null);
                     break;
-                }
-			    case NPTypeCode.UInt32: 
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<uint>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        uint max = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val > max)
-                            {
-                                max = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-                    break;
                 }
 			    case NPTypeCode.Int64: 
                 {
@@ -240,84 +162,6 @@ public override NDArray ReduceArgMax(NDArray arr, int? axis_)
                         ret.SetInt32(maxAt, iterIndex);
                     } while (iterAxis.Next() != null && iterRet.Next() != null);
                     break;
-                }
-			    case NPTypeCode.UInt64: 
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<ulong>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        ulong max = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val > max)
-                            {
-                                max = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-                    break;
-                }
-			    case NPTypeCode.Char: 
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<char>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        char max = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val > max)
-                            {
-                                max = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-                    break;
-                }
-			    case NPTypeCode.Double: 
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<double>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        double max = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val > max)
-                            {
-                                max = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-                    break;
                 }
 			    case NPTypeCode.Single: 
                 {
@@ -345,16 +189,16 @@ public override NDArray ReduceArgMax(NDArray arr, int? axis_)
                     } while (iterAxis.Next() != null && iterRet.Next() != null);
                     break;
                 }
-			    case NPTypeCode.Decimal: 
+			    case NPTypeCode.Double: 
                 {
                     int at;
                     do
                     {
-                        var iter = arr[slices].AsIterator<decimal>();
+                        var iter = arr[slices].AsIterator<double>();
                         var moveNext = iter.MoveNext;
                         var hasNext = iter.HasNext;
                         int idx = 1, maxAt = 0;
-                        decimal max = moveNext();
+                        double max = moveNext();
                         while (hasNext())
                         {
                             var val = moveNext();
@@ -390,7 +234,7 @@ protected object argmax_elementwise(NDArray arr)
             if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
                 return NDArray.Scalar(0);
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -445,48 +289,6 @@ protected object argmax_elementwise(NDArray arr)
                         idx++;
                     }
 
-                    return maxAt;
-                }
-			    case NPTypeCode.Int16: 
-                {
-                    var iter = arr.AsIterator<short>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    short max = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val > max)
-                        {
-                            max = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
-                    return maxAt;
-                }
-			    case NPTypeCode.UInt16: 
-                {
-                    var iter = arr.AsIterator<ushort>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    ushort max = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val > max)
-                        {
-                            max = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
                     return maxAt;
                 }
 			    case NPTypeCode.Int32: 
@@ -508,27 +310,6 @@ protected object argmax_elementwise(NDArray arr)
                         idx++;
                     }
 
-                    return maxAt;
-                }
-			    case NPTypeCode.UInt32: 
-                {
-                    var iter = arr.AsIterator<uint>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    uint max = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val > max)
-                        {
-                            max = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
                     return maxAt;
                 }
 			    case NPTypeCode.Int64: 
@@ -550,69 +331,6 @@ protected object argmax_elementwise(NDArray arr)
                         idx++;
                     }
 
-                    return maxAt;
-                }
-			    case NPTypeCode.UInt64: 
-                {
-                    var iter = arr.AsIterator<ulong>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    ulong max = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val > max)
-                        {
-                            max = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
-                    return maxAt;
-                }
-			    case NPTypeCode.Char: 
-                {
-                    var iter = arr.AsIterator<char>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    char max = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val > max)
-                        {
-                            max = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
-                    return maxAt;
-                }
-			    case NPTypeCode.Double: 
-                {
-                    var iter = arr.AsIterator<double>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    double max = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val > max)
-                        {
-                            max = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
                     return maxAt;
                 }
 			    case NPTypeCode.Single: 
@@ -636,13 +354,13 @@ protected object argmax_elementwise(NDArray arr)
 
                     return maxAt;
                 }
-			    case NPTypeCode.Decimal: 
+			    case NPTypeCode.Double: 
                 {
-                    var iter = arr.AsIterator<decimal>();
+                    var iter = arr.AsIterator<double>();
                     var moveNext = iter.MoveNext;
                     var hasNext = iter.HasNext;
                     int idx = 1, maxAt = 0;
-                    decimal max = moveNext();
+                    double max = moveNext();
                     while (hasNext())
                     {
                         var val = moveNext();
diff --git a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.ArgMin.cs b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.ArgMin.cs
index 418bd83f4..43d3d0f44 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.ArgMin.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.ArgMin.cs
@@ -43,7 +43,7 @@ public override NDArray ReduceArgMin(NDArray arr, int? axis_)
             var iterIndex = iterRet.Index;
             var slices = iterAxis.Slices;
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -82,10 +82,9 @@ public override NDArray ReduceArgMin(NDArray arr, int? axis_)
 #else
 
             #region Compute
-
             switch (arr.GetTypeCode)
-            {
-                case NPTypeCode.Byte:
+		    {
+			    case NPTypeCode.Byte: 
                 {
                     int at;
                     do
@@ -109,67 +108,9 @@ public override NDArray ReduceArgMin(NDArray arr, int? axis_)
 
                         ret.SetInt32(maxAt, iterIndex);
                     } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                     break;
                 }
-
-                case NPTypeCode.Int16:
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<short>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        short min = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val < min)
-                            {
-                                min = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                    break;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<ushort>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        ushort min = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val < min)
-                            {
-                                min = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                    break;
-                }
-
-                case NPTypeCode.Int32:
+			    case NPTypeCode.Int32: 
                 {
                     int at;
                     do
@@ -193,39 +134,9 @@ public override NDArray ReduceArgMin(NDArray arr, int? axis_)
 
                         ret.SetInt32(maxAt, iterIndex);
                     } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                     break;
                 }
-
-                case NPTypeCode.UInt32:
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<uint>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        uint min = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val < min)
-                            {
-                                min = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                    break;
-                }
-
-                case NPTypeCode.Int64:
+			    case NPTypeCode.Int64: 
                 {
                     int at;
                     do
@@ -249,95 +160,9 @@ public override NDArray ReduceArgMin(NDArray arr, int? axis_)
 
                         ret.SetInt32(maxAt, iterIndex);
                     } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                    break;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<ulong>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        ulong min = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val < min)
-                            {
-                                min = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<char>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        char min = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val < min)
-                            {
-                                min = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                     break;
                 }
-
-                case NPTypeCode.Double:
-                {
-                    int at;
-                    do
-                    {
-                        var iter = arr[slices].AsIterator<double>();
-                        var moveNext = iter.MoveNext;
-                        var hasNext = iter.HasNext;
-                        int idx = 1, maxAt = 0;
-                        double min = moveNext();
-                        while (hasNext())
-                        {
-                            var val = moveNext();
-                            if (val < min)
-                            {
-                                min = val;
-                                maxAt = idx;
-                            }
-
-                            idx++;
-                        }
-
-                        ret.SetInt32(maxAt, iterIndex);
-                    } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                    break;
-                }
-
-                case NPTypeCode.Single:
+			    case NPTypeCode.Single: 
                 {
                     int at;
                     do
@@ -361,20 +186,18 @@ public override NDArray ReduceArgMin(NDArray arr, int? axis_)
 
                         ret.SetInt32(maxAt, iterIndex);
                     } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                     break;
                 }
-
-                case NPTypeCode.Decimal:
+			    case NPTypeCode.Double: 
                 {
                     int at;
                     do
                     {
-                        var iter = arr[slices].AsIterator<decimal>();
+                        var iter = arr[slices].AsIterator<double>();
                         var moveNext = iter.MoveNext;
                         var hasNext = iter.HasNext;
                         int idx = 1, maxAt = 0;
-                        decimal min = moveNext();
+                        double min = moveNext();
                         while (hasNext())
                         {
                             var val = moveNext();
@@ -389,16 +212,12 @@ public override NDArray ReduceArgMin(NDArray arr, int? axis_)
 
                         ret.SetInt32(maxAt, iterIndex);
                     } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                     break;
                 }
-
-                default:
-                    throw new NotSupportedException();
-            }
-
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
 
             return ret;
@@ -413,7 +232,7 @@ protected object argmin_elementwise(NDArray arr)
         {
             if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
                 return NDArray.Scalar(0);
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -447,10 +266,9 @@ protected object argmin_elementwise(NDArray arr)
 #else
 
             #region Compute
-
             switch (arr.GetTypeCode)
-            {
-                case NPTypeCode.Byte:
+		    {
+			    case NPTypeCode.Byte: 
                 {
                     var iter = arr.AsIterator<byte>();
                     var moveNext = iter.MoveNext;
@@ -471,52 +289,7 @@ protected object argmin_elementwise(NDArray arr)
 
                     return maxAt;
                 }
-
-                case NPTypeCode.Int16:
-                {
-                    var iter = arr.AsIterator<short>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    short min = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val < min)
-                        {
-                            min = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
-                    return maxAt;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    var iter = arr.AsIterator<ushort>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    ushort min = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val < min)
-                        {
-                            min = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
-                    return maxAt;
-                }
-
-                case NPTypeCode.Int32:
+			    case NPTypeCode.Int32: 
                 {
                     var iter = arr.AsIterator<int>();
                     var moveNext = iter.MoveNext;
@@ -537,30 +310,7 @@ protected object argmin_elementwise(NDArray arr)
 
                     return maxAt;
                 }
-
-                case NPTypeCode.UInt32:
-                {
-                    var iter = arr.AsIterator<uint>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    uint min = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val < min)
-                        {
-                            min = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
-                    return maxAt;
-                }
-
-                case NPTypeCode.Int64:
+			    case NPTypeCode.Int64: 
                 {
                     var iter = arr.AsIterator<long>();
                     var moveNext = iter.MoveNext;
@@ -581,74 +331,7 @@ protected object argmin_elementwise(NDArray arr)
 
                     return maxAt;
                 }
-
-                case NPTypeCode.UInt64:
-                {
-                    var iter = arr.AsIterator<ulong>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    ulong min = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val < min)
-                        {
-                            min = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
-                    return maxAt;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    var iter = arr.AsIterator<char>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    char min = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val < min)
-                        {
-                            min = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
-                    return maxAt;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    var iter = arr.AsIterator<double>();
-                    var moveNext = iter.MoveNext;
-                    var hasNext = iter.HasNext;
-                    int idx = 1, maxAt = 0;
-                    double min = moveNext();
-                    while (hasNext())
-                    {
-                        var val = moveNext();
-                        if (val < min)
-                        {
-                            min = val;
-                            maxAt = idx;
-                        }
-
-                        idx++;
-                    }
-
-                    return maxAt;
-                }
-
-                case NPTypeCode.Single:
+			    case NPTypeCode.Single: 
                 {
                     var iter = arr.AsIterator<float>();
                     var moveNext = iter.MoveNext;
@@ -669,14 +352,13 @@ protected object argmin_elementwise(NDArray arr)
 
                     return maxAt;
                 }
-
-                case NPTypeCode.Decimal:
+			    case NPTypeCode.Double: 
                 {
-                    var iter = arr.AsIterator<decimal>();
+                    var iter = arr.AsIterator<double>();
                     var moveNext = iter.MoveNext;
                     var hasNext = iter.HasNext;
                     int idx = 1, maxAt = 0;
-                    decimal min = moveNext();
+                    double min = moveNext();
                     while (hasNext())
                     {
                         var val = moveNext();
@@ -691,13 +373,10 @@ protected object argmin_elementwise(NDArray arr)
 
                     return maxAt;
                 }
-
-                default:
-                    throw new NotSupportedException();
-            }
-
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
     }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.CumAdd.cs b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.CumAdd.cs
index 162248659..254df0036 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.CumAdd.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.CumAdd.cs
@@ -44,7 +44,7 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
             var iterAxis = new NDCoordinatesAxisIncrementor(ref shape, axis);
             var slices = iterAxis.Slices;
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -109,42 +109,6 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                                 }
                             } while (iterAxis.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ushort) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int32: 
                         {
@@ -163,24 +127,6 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                                 }
                             } while (iterAxis.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (uint) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Int64: 
                         {
@@ -199,60 +145,6 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                                 }
                             } while (iterAxis.Next() != null);
                             break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ulong) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (char) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<byte>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (double) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
                         }
 			            case NPTypeCode.Single: 
                         {
@@ -272,19 +164,19 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var iter = arr[slices].AsIterator<byte>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
+                                var iterAxedRet = ret[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
+                                double sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (decimal) moveNext();
+                                    sum += (double) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
@@ -295,7 +187,7 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
 		            }
                     break;
                 }
-			    case NPTypeCode.Int16: 
+			    case NPTypeCode.Int32: 
                 {
                     switch (ret.GetTypeCode)
 		            {
@@ -303,7 +195,7 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<int>();
                                 var iterAxedRet = ret[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
@@ -317,145 +209,136 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<short>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<int>();
+                                var iterAxedRet = ret[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
+                                int sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (ushort) moveNext();
+                                    sum += (int) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
-                                var iterAxedRet = ret[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<int>();
+                                var iterAxedRet = ret[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                int sum = default;
+                                long sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (int) moveNext();
+                                    sum += (long) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
+                                var iter = arr[slices].AsIterator<int>();
+                                var iterAxedRet = ret[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
+                                float sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (uint) moveNext();
+                                    sum += (float) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
-                                var iterAxedRet = ret[slices].AsIterator<long>();
+                                var iter = arr[slices].AsIterator<int>();
+                                var iterAxedRet = ret[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                long sum = default;
+                                double sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (long) moveNext();
+                                    sum += (double) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt64: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int64: 
+                {
+                    switch (ret.GetTypeCode)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
+                                var iter = arr[slices].AsIterator<long>();
+                                var iterAxedRet = ret[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
+                                byte sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (ulong) moveNext();
+                                    sum += (byte) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
+                                var iter = arr[slices].AsIterator<long>();
+                                var iterAxedRet = ret[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
+                                int sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (char) moveNext();
+                                    sum += (int) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Double: 
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
+                                var iter = arr[slices].AsIterator<long>();
+                                var iterAxedRet = ret[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
+                                long sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (double) moveNext();
+                                    sum += (long) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
@@ -465,7 +348,7 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
+                                var iter = arr[slices].AsIterator<long>();
                                 var iterAxedRet = ret[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
@@ -479,19 +362,19 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<short>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
+                                var iter = arr[slices].AsIterator<long>();
+                                var iterAxedRet = ret[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
+                                double sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (decimal) moveNext();
+                                    sum += (double) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
@@ -502,7 +385,7 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
 		            }
                     break;
                 }
-			    case NPTypeCode.UInt16: 
+			    case NPTypeCode.Single: 
                 {
                     switch (ret.GetTypeCode)
 		            {
@@ -510,7 +393,7 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
                                 var iterAxedRet = ret[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
@@ -524,145 +407,136 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<float>();
+                                var iterAxedRet = ret[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
+                                int sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (ushort) moveNext();
+                                    sum += (int) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var iterAxedRet = ret[slices].AsIterator<int>();
+                                var iter = arr[slices].AsIterator<float>();
+                                var iterAxedRet = ret[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                int sum = default;
+                                long sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (int) moveNext();
+                                    sum += (long) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
+                                var iter = arr[slices].AsIterator<float>();
+                                var iterAxedRet = ret[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
+                                float sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (uint) moveNext();
+                                    sum += (float) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var iterAxedRet = ret[slices].AsIterator<long>();
+                                var iter = arr[slices].AsIterator<float>();
+                                var iterAxedRet = ret[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                long sum = default;
+                                double sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (long) moveNext();
+                                    sum += (double) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.UInt64: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Double: 
+                {
+                    switch (ret.GetTypeCode)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
+                                var iter = arr[slices].AsIterator<double>();
+                                var iterAxedRet = ret[slices].AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
+                                byte sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (ulong) moveNext();
+                                    sum += (byte) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
+                                var iter = arr[slices].AsIterator<double>();
+                                var iterAxedRet = ret[slices].AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
+                                int sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (char) moveNext();
+                                    sum += (int) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Double: 
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
+                                var iter = arr[slices].AsIterator<double>();
+                                var iterAxedRet = ret[slices].AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
+                                long sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (double) moveNext();
+                                    sum += (long) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
@@ -672,7 +546,7 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
+                                var iter = arr[slices].AsIterator<double>();
                                 var iterAxedRet = ret[slices].AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
@@ -686,19 +560,19 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
                             } while (iterAxis.Next() != null);
                             break;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
-                                var iter = arr[slices].AsIterator<ushort>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
+                                var iter = arr[slices].AsIterator<double>();
+                                var iterAxedRet = ret[slices].AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
+                                double sum = default;
                                 while (hasNext())
                                 {
-                                    sum += (decimal) moveNext();
+                                    sum += (double) moveNext();
                                     setNext() = sum;
                                 }
                             } while (iterAxis.Next() != null);
@@ -709,3214 +583,78 @@ public override unsafe NDArray ReduceCumAdd(in NDArray arr, int? axis_, NPTypeCo
 		            }
                     break;
                 }
-			    case NPTypeCode.Int32: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                byte sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (byte) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ushort) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                int sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (int) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (uint) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                long sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (long) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ulong) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (char) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (double) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                float sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (float) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<int>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (decimal) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt32: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                byte sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (byte) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ushort) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                int sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (int) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (uint) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                long sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (long) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ulong) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (char) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (double) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                float sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (float) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<uint>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (decimal) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int64: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                byte sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (byte) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ushort) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                int sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (int) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (uint) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                long sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (long) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ulong) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (char) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (double) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                float sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (float) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<long>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (decimal) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt64: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                byte sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (byte) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ushort) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                int sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (int) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (uint) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                long sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (long) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ulong) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (char) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (double) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                float sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (float) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<ulong>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (decimal) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Char: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                byte sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (byte) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ushort) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                int sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (int) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (uint) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                long sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (long) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ulong) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (char) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (double) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                float sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (float) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<char>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (decimal) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Double: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                byte sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (byte) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ushort) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                int sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (int) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (uint) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                long sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (long) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ulong) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (char) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (double) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                float sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (float) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<double>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (decimal) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Single: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                byte sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (byte) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ushort) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                int sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (int) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (uint) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                long sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (long) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ulong) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (char) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (double) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                float sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (float) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<float>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (decimal) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Decimal: 
-                {
-                    switch (ret.GetTypeCode)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                byte sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (byte) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                short sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (short) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ushort sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ushort) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                int sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (int) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                uint sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (uint) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                long sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (long) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                ulong sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (ulong) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                char sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (char) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                double sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (double) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                float sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (float) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            do
-                            {
-                                var iter = arr[slices].AsIterator<decimal>();
-                                var iterAxedRet = ret[slices].AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var setNext = iterAxedRet.MoveNextReference;
-                                decimal sum = default;
-                                while (hasNext())
-                                {
-                                    sum += (decimal) moveNext();
-                                    setNext() = sum;
-                                }
-                            } while (iterAxis.Next() != null);
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#endif
-
-            return ret;
-        }
-
-        public NDArray CumSumElementwise<T>(in NDArray arr, NPTypeCode? typeCode) where T : unmanaged
-        {
-            var ret = cumsum_elementwise(arr, typeCode);
-            return typeCode.HasValue && typeCode.Value != ret.typecode ? ret.astype(typeCode.Value, true) : ret;
-        }
-
-        protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode)
-        {
-            if (arr.Shape.IsScalar || (arr.Shape.NDim == 1 && arr.Shape.size == 1))
-                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
-
-            var retType = typeCode ?? (arr.GetTypeCode.GetAccumulatingType());
-            var ret = new NDArray(retType, Shape.Vector(arr.size));
-
-#if _REGEN
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    %foreach supported_numericals,supported_numericals_lowercase%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase%
-			            case NPTypeCode.#101: 
-                        {
-                            var iter = arr.AsIterator<#2>();
-                            var addr = (#102*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            |#102 sum = default;
-                            while (hasNext())
-                            {
-                                sum += (#102) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    %
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#else
-
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    case NPTypeCode.Byte: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (byte*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            byte sum = default;
-                            while (hasNext())
-                            {
-                                sum += (byte) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (ushort*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ushort sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ushort) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (int*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            int sum = default;
-                            while (hasNext())
-                            {
-                                sum += (int) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (uint*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            uint sum = default;
-                            while (hasNext())
-                            {
-                                sum += (uint) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (long*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            long sum = default;
-                            while (hasNext())
-                            {
-                                sum += (long) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (ulong*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ulong sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ulong) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (char*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            char sum = default;
-                            while (hasNext())
-                            {
-                                sum += (char) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (double*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            double sum = default;
-                            while (hasNext())
-                            {
-                                sum += (double) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (float*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            float sum = default;
-                            while (hasNext())
-                            {
-                                sum += (float) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var addr = (decimal*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            decimal sum = default;
-                            while (hasNext())
-                            {
-                                sum += (decimal) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int16: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (byte*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            byte sum = default;
-                            while (hasNext())
-                            {
-                                sum += (byte) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (ushort*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ushort sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ushort) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (int*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            int sum = default;
-                            while (hasNext())
-                            {
-                                sum += (int) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (uint*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            uint sum = default;
-                            while (hasNext())
-                            {
-                                sum += (uint) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (long*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            long sum = default;
-                            while (hasNext())
-                            {
-                                sum += (long) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (ulong*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ulong sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ulong) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (char*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            char sum = default;
-                            while (hasNext())
-                            {
-                                sum += (char) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (double*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            double sum = default;
-                            while (hasNext())
-                            {
-                                sum += (double) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (float*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            float sum = default;
-                            while (hasNext())
-                            {
-                                sum += (float) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var addr = (decimal*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            decimal sum = default;
-                            while (hasNext())
-                            {
-                                sum += (decimal) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt16: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (byte*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            byte sum = default;
-                            while (hasNext())
-                            {
-                                sum += (byte) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (ushort*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ushort sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ushort) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (int*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            int sum = default;
-                            while (hasNext())
-                            {
-                                sum += (int) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (uint*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            uint sum = default;
-                            while (hasNext())
-                            {
-                                sum += (uint) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (long*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            long sum = default;
-                            while (hasNext())
-                            {
-                                sum += (long) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (ulong*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ulong sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ulong) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (char*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            char sum = default;
-                            while (hasNext())
-                            {
-                                sum += (char) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (double*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            double sum = default;
-                            while (hasNext())
-                            {
-                                sum += (double) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (float*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            float sum = default;
-                            while (hasNext())
-                            {
-                                sum += (float) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var addr = (decimal*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            decimal sum = default;
-                            while (hasNext())
-                            {
-                                sum += (decimal) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int32: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (byte*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            byte sum = default;
-                            while (hasNext())
-                            {
-                                sum += (byte) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (ushort*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ushort sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ushort) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (int*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            int sum = default;
-                            while (hasNext())
-                            {
-                                sum += (int) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (uint*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            uint sum = default;
-                            while (hasNext())
-                            {
-                                sum += (uint) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (long*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            long sum = default;
-                            while (hasNext())
-                            {
-                                sum += (long) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (ulong*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ulong sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ulong) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (char*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            char sum = default;
-                            while (hasNext())
-                            {
-                                sum += (char) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (double*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            double sum = default;
-                            while (hasNext())
-                            {
-                                sum += (double) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (float*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            float sum = default;
-                            while (hasNext())
-                            {
-                                sum += (float) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var addr = (decimal*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            decimal sum = default;
-                            while (hasNext())
-                            {
-                                sum += (decimal) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt32: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (byte*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            byte sum = default;
-                            while (hasNext())
-                            {
-                                sum += (byte) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (ushort*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ushort sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ushort) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (int*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            int sum = default;
-                            while (hasNext())
-                            {
-                                sum += (int) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (uint*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            uint sum = default;
-                            while (hasNext())
-                            {
-                                sum += (uint) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (long*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            long sum = default;
-                            while (hasNext())
-                            {
-                                sum += (long) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (ulong*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ulong sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ulong) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (char*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            char sum = default;
-                            while (hasNext())
-                            {
-                                sum += (char) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (double*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            double sum = default;
-                            while (hasNext())
-                            {
-                                sum += (double) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (float*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            float sum = default;
-                            while (hasNext())
-                            {
-                                sum += (float) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var addr = (decimal*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            decimal sum = default;
-                            while (hasNext())
-                            {
-                                sum += (decimal) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int64: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (byte*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            byte sum = default;
-                            while (hasNext())
-                            {
-                                sum += (byte) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (ushort*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ushort sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ushort) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (int*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            int sum = default;
-                            while (hasNext())
-                            {
-                                sum += (int) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (uint*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            uint sum = default;
-                            while (hasNext())
-                            {
-                                sum += (uint) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (long*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            long sum = default;
-                            while (hasNext())
-                            {
-                                sum += (long) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (ulong*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ulong sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ulong) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (char*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            char sum = default;
-                            while (hasNext())
-                            {
-                                sum += (char) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (double*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            double sum = default;
-                            while (hasNext())
-                            {
-                                sum += (double) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (float*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            float sum = default;
-                            while (hasNext())
-                            {
-                                sum += (float) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var addr = (decimal*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            decimal sum = default;
-                            while (hasNext())
-                            {
-                                sum += (decimal) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt64: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (byte*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            byte sum = default;
-                            while (hasNext())
-                            {
-                                sum += (byte) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (ushort*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ushort sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ushort) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (int*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            int sum = default;
-                            while (hasNext())
-                            {
-                                sum += (int) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (uint*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            uint sum = default;
-                            while (hasNext())
-                            {
-                                sum += (uint) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (long*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            long sum = default;
-                            while (hasNext())
-                            {
-                                sum += (long) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (ulong*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ulong sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ulong) moveNext();
-                                *(addr + i++) = sum;
-                            }
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#endif
 
-                            return ret;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (char*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            char sum = default;
-                            while (hasNext())
-                            {
-                                sum += (char) moveNext();
-                                *(addr + i++) = sum;
-                            }
+            return ret;
+        }
 
-                            return ret;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (double*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            double sum = default;
-                            while (hasNext())
-                            {
-                                sum += (double) moveNext();
-                                *(addr + i++) = sum;
-                            }
+        public NDArray CumSumElementwise<T>(in NDArray arr, NPTypeCode? typeCode) where T : unmanaged
+        {
+            var ret = cumsum_elementwise(arr, typeCode);
+            return typeCode.HasValue && typeCode.Value != ret.typecode ? ret.astype(typeCode.Value, true) : ret;
+        }
 
-                            return ret;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (float*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            float sum = default;
-                            while (hasNext())
-                            {
-                                sum += (float) moveNext();
-                                *(addr + i++) = sum;
-                            }
+        protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode)
+        {
+            if (arr.Shape.IsScalar || (arr.Shape.NDim == 1 && arr.Shape.size == 1))
+                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
 
-                            return ret;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var addr = (decimal*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            decimal sum = default;
-                            while (hasNext())
-                            {
-                                sum += (decimal) moveNext();
-                                *(addr + i++) = sum;
-                            }
+            var retType = typeCode ?? (arr.GetTypeCode.GetAccumulatingType());
+            var ret = new NDArray(retType, Shape.Vector(arr.size));
 
-                            return ret;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Char: 
+#if _REGEN1
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    %foreach supported_numericals,supported_numericals_lowercase%
+			    case NPTypeCode.#1: 
                 {
                     switch (retType)
 		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (byte*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            byte sum = default;
-                            while (hasNext())
-                            {
-                                sum += (byte) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (ushort*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ushort sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ushort) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (int*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            int sum = default;
-                            while (hasNext())
-                            {
-                                sum += (int) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (uint*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            uint sum = default;
-                            while (hasNext())
-                            {
-                                sum += (uint) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (long*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            long sum = default;
-                            while (hasNext())
-                            {
-                                sum += (long) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (ulong*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ulong sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ulong) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (char*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            char sum = default;
-                            while (hasNext())
-                            {
-                                sum += (char) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (double*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            double sum = default;
-                            while (hasNext())
-                            {
-                                sum += (double) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (float*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            float sum = default;
-                            while (hasNext())
-                            {
-                                sum += (float) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Decimal: 
+			            %foreach supported_numericals,supported_numericals_lowercase%
+			            case NPTypeCode.#101: 
                         {
-                            var iter = arr.AsIterator<char>();
-                            var addr = (decimal*)ret.Address;
+                            var iter = arr.AsIterator<#2>();
+                            var addr = (#102*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            decimal sum = default;
+                            |#102 sum = default;
                             while (hasNext())
                             {
-                                sum += (decimal) moveNext();
+                                sum += (#102) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
+			            %
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.Double: 
+			    %
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#else
+
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    case NPTypeCode.Byte: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<byte>();
                             var addr = (byte*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
@@ -3930,129 +668,122 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
 
                             return ret;
                         }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<double>();
-                            var addr = (ushort*)ret.Address;
+                            var iter = arr.AsIterator<byte>();
+                            var addr = (int*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            ushort sum = default;
+                            int sum = default;
                             while (hasNext())
                             {
-                                sum += (ushort) moveNext();
+                                sum += (int) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<double>();
-                            var addr = (int*)ret.Address;
+                            var iter = arr.AsIterator<byte>();
+                            var addr = (long*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            int sum = default;
+                            long sum = default;
                             while (hasNext())
                             {
-                                sum += (int) moveNext();
+                                sum += (long) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<double>();
-                            var addr = (uint*)ret.Address;
+                            var iter = arr.AsIterator<byte>();
+                            var addr = (float*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            uint sum = default;
+                            float sum = default;
                             while (hasNext())
                             {
-                                sum += (uint) moveNext();
+                                sum += (float) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<double>();
-                            var addr = (long*)ret.Address;
+                            var iter = arr.AsIterator<byte>();
+                            var addr = (double*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            long sum = default;
+                            double sum = default;
                             while (hasNext())
                             {
-                                sum += (long) moveNext();
+                                sum += (double) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.UInt64: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int32: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<double>();
-                            var addr = (ulong*)ret.Address;
+                            var iter = arr.AsIterator<int>();
+                            var addr = (byte*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            ulong sum = default;
+                            byte sum = default;
                             while (hasNext())
                             {
-                                sum += (ulong) moveNext();
+                                sum += (byte) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<double>();
-                            var addr = (char*)ret.Address;
+                            var iter = arr.AsIterator<int>();
+                            var addr = (int*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            char sum = default;
+                            int sum = default;
                             while (hasNext())
                             {
-                                sum += (char) moveNext();
+                                sum += (int) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.Double: 
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<double>();
-                            var addr = (double*)ret.Address;
+                            var iter = arr.AsIterator<int>();
+                            var addr = (long*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            double sum = default;
+                            long sum = default;
                             while (hasNext())
                             {
-                                sum += (double) moveNext();
+                                sum += (long) moveNext();
                                 *(addr + i++) = sum;
                             }
 
@@ -4060,7 +791,7 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
                         }
 			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var addr = (float*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
@@ -4074,17 +805,17 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
 
                             return ret;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<double>();
-                            var addr = (decimal*)ret.Address;
+                            var iter = arr.AsIterator<int>();
+                            var addr = (double*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            decimal sum = default;
+                            double sum = default;
                             while (hasNext())
                             {
-                                sum += (decimal) moveNext();
+                                sum += (double) moveNext();
                                 *(addr + i++) = sum;
                             }
 
@@ -4095,13 +826,13 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
 		            }
                     break;
                 }
-			    case NPTypeCode.Single: 
+			    case NPTypeCode.Int64: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var addr = (byte*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
@@ -4115,129 +846,122 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
 
                             return ret;
                         }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<float>();
-                            var addr = (ushort*)ret.Address;
+                            var iter = arr.AsIterator<long>();
+                            var addr = (int*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            ushort sum = default;
+                            int sum = default;
                             while (hasNext())
                             {
-                                sum += (ushort) moveNext();
+                                sum += (int) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<float>();
-                            var addr = (int*)ret.Address;
+                            var iter = arr.AsIterator<long>();
+                            var addr = (long*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            int sum = default;
+                            long sum = default;
                             while (hasNext())
                             {
-                                sum += (int) moveNext();
+                                sum += (long) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<float>();
-                            var addr = (uint*)ret.Address;
+                            var iter = arr.AsIterator<long>();
+                            var addr = (float*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            uint sum = default;
+                            float sum = default;
                             while (hasNext())
                             {
-                                sum += (uint) moveNext();
+                                sum += (float) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<float>();
-                            var addr = (long*)ret.Address;
+                            var iter = arr.AsIterator<long>();
+                            var addr = (double*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            long sum = default;
+                            double sum = default;
                             while (hasNext())
                             {
-                                sum += (long) moveNext();
+                                sum += (double) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.UInt64: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             var iter = arr.AsIterator<float>();
-                            var addr = (ulong*)ret.Address;
+                            var addr = (byte*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            ulong sum = default;
+                            byte sum = default;
                             while (hasNext())
                             {
-                                sum += (ulong) moveNext();
+                                sum += (byte) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Int32: 
                         {
                             var iter = arr.AsIterator<float>();
-                            var addr = (char*)ret.Address;
+                            var addr = (int*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            char sum = default;
+                            int sum = default;
                             while (hasNext())
                             {
-                                sum += (char) moveNext();
+                                sum += (int) moveNext();
                                 *(addr + i++) = sum;
                             }
 
                             return ret;
                         }
-			            case NPTypeCode.Double: 
+			            case NPTypeCode.Int64: 
                         {
                             var iter = arr.AsIterator<float>();
-                            var addr = (double*)ret.Address;
+                            var addr = (long*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            double sum = default;
+                            long sum = default;
                             while (hasNext())
                             {
-                                sum += (double) moveNext();
+                                sum += (long) moveNext();
                                 *(addr + i++) = sum;
                             }
 
@@ -4259,17 +983,17 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
 
                             return ret;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             var iter = arr.AsIterator<float>();
-                            var addr = (decimal*)ret.Address;
+                            var addr = (double*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            decimal sum = default;
+                            double sum = default;
                             while (hasNext())
                             {
-                                sum += (decimal) moveNext();
+                                sum += (double) moveNext();
                                 *(addr + i++) = sum;
                             }
 
@@ -4280,13 +1004,13 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
 		            }
                     break;
                 }
-			    case NPTypeCode.Decimal: 
+			    case NPTypeCode.Double: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var addr = (byte*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
@@ -4298,43 +1022,11 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
                                 *(addr + i++) = sum;
                             }
 
-                            return ret;
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var addr = (short*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            short sum = default;
-                            while (hasNext())
-                            {
-                                sum += (short) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var addr = (ushort*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ushort sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ushort) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
                             return ret;
                         }
 			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var addr = (int*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
@@ -4346,27 +1038,11 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
                                 *(addr + i++) = sum;
                             }
 
-                            return ret;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var addr = (uint*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            uint sum = default;
-                            while (hasNext())
-                            {
-                                sum += (uint) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
                             return ret;
                         }
 			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var addr = (long*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
@@ -4378,59 +1054,11 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
                                 *(addr + i++) = sum;
                             }
 
-                            return ret;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var addr = (ulong*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            ulong sum = default;
-                            while (hasNext())
-                            {
-                                sum += (ulong) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var addr = (char*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            char sum = default;
-                            while (hasNext())
-                            {
-                                sum += (char) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
-                            return ret;
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var addr = (double*)ret.Address;
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int i = 0;
-                            double sum = default;
-                            while (hasNext())
-                            {
-                                sum += (double) moveNext();
-                                *(addr + i++) = sum;
-                            }
-
                             return ret;
                         }
 			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var addr = (float*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
@@ -4444,17 +1072,17 @@ protected unsafe NDArray cumsum_elementwise(in NDArray arr, NPTypeCode? typeCode
 
                             return ret;
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<decimal>();
-                            var addr = (decimal*)ret.Address;
+                            var iter = arr.AsIterator<double>();
+                            var addr = (double*)ret.Address;
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int i = 0;
-                            decimal sum = default;
+                            double sum = default;
                             while (hasNext())
                             {
-                                sum += (decimal) moveNext();
+                                sum += (double) moveNext();
                                 *(addr + i++) = sum;
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Mean.cs b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Mean.cs
index 0e5029dda..bc4bdd07c 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Mean.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Mean.cs
@@ -61,7 +61,7 @@ public override NDArray ReduceMean(in NDArray arr, int? axis_, bool keepdims = f
 
             //resolve the accumulator type
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -101,32 +101,13 @@ public override NDArray ReduceMean(in NDArray arr, int? axis_, bool keepdims = f
 #else
 
             #region Compute
-
             switch (arr.GetTypeCode)
-            {
-                case NPTypeCode.Byte:
+		    {
+			    case NPTypeCode.Byte: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
@@ -134,17 +115,15 @@ public override NDArray ReduceMean(in NDArray arr, int? axis_, bool keepdims = f
                                 var iter = slice.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = 0;
+                                Byte sum = 0;
                                 while (hasNext())
-                                    sum += (int)moveNext();
+                                    sum += (Byte) moveNext();
 
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
+                                ret.SetByte(Converts.ToByte(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
@@ -152,17 +131,15 @@ public override NDArray ReduceMean(in NDArray arr, int? axis_, bool keepdims = f
                                 var iter = slice.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = 0;
+                                Int32 sum = 0;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (Int32) moveNext();
 
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
@@ -170,17 +147,15 @@ public override NDArray ReduceMean(in NDArray arr, int? axis_, bool keepdims = f
                                 var iter = slice.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = 0;
+                                Int64 sum = 0L;
                                 while (hasNext())
-                                    sum += (int)moveNext();
+                                    sum += (Int64) moveNext();
 
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
@@ -188,17 +163,15 @@ public override NDArray ReduceMean(in NDArray arr, int? axis_, bool keepdims = f
                                 var iter = slice.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = 0u;
+                                Single sum = 0f;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (Single) moveNext();
 
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
@@ -206,3966 +179,759 @@ public override NDArray ReduceMean(in NDArray arr, int? axis_, bool keepdims = f
                                 var iter = slice.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long sum = 0L;
+                                Double sum = 0d;
                                 while (hasNext())
-                                    sum += (long)moveNext();
+                                    sum += (Double) moveNext();
 
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int32: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
+                                var iter = slice.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
+                                Byte sum = 0;
                                 while (hasNext())
-                                    sum += (ulong)moveNext();
+                                    sum += (Byte) moveNext();
 
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
+                                ret.SetByte(Converts.ToByte(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
+                                var iter = slice.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = '\0';
+                                Int32 sum = 0;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (Int32) moveNext();
 
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
+                                var iter = slice.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                double sum = 0d;
+                                Int64 sum = 0L;
                                 while (hasNext())
-                                    sum += (double)moveNext();
+                                    sum += (Int64) moveNext();
 
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
+                                var iter = slice.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                float sum = 0f;
+                                Single sum = 0f;
                                 while (hasNext())
-                                    sum += (float)moveNext();
+                                    sum += (Single) moveNext();
 
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
+                                var iter = slice.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal sum = 0m;
+                                Double sum = 0d;
                                 while (hasNext())
-                                    sum += (decimal)moveNext();
+                                    sum += (Double) moveNext();
 
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Int16:
+			    case NPTypeCode.Int64: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = 0;
+                                Byte sum = 0;
                                 while (hasNext())
-                                    sum += (int)moveNext();
+                                    sum += (Byte) moveNext();
 
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
+                                ret.SetByte(Converts.ToByte(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = 0;
+                                Int32 sum = 0;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (Int32) moveNext();
 
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = 0;
+                                Int64 sum = 0L;
                                 while (hasNext())
-                                    sum += (int)moveNext();
+                                    sum += (Int64) moveNext();
 
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = 0u;
+                                Single sum = 0f;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (Single) moveNext();
 
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long sum = 0L;
+                                Double sum = 0d;
                                 while (hasNext())
-                                    sum += (long)moveNext();
+                                    sum += (Double) moveNext();
 
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
+                                Byte sum = 0;
                                 while (hasNext())
-                                    sum += (ulong)moveNext();
+                                    sum += (Byte) moveNext();
 
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
+                                ret.SetByte(Converts.ToByte(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = '\0';
+                                Int32 sum = 0;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (Int32) moveNext();
 
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                double sum = 0d;
+                                Int64 sum = 0L;
                                 while (hasNext())
-                                    sum += (double)moveNext();
+                                    sum += (Int64) moveNext();
 
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                float sum = 0f;
+                                Single sum = 0f;
                                 while (hasNext())
-                                    sum += (float)moveNext();
+                                    sum += (Single) moveNext();
 
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal sum = 0m;
+                                Double sum = 0d;
                                 while (hasNext())
-                                    sum += (decimal)moveNext();
+                                    sum += (Double) moveNext();
 
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.UInt16:
+			    case NPTypeCode.Double: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
+                                var iter = slice.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = 0;
+                                Byte sum = 0;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (Byte) moveNext();
 
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
+                                ret.SetByte(Converts.ToByte(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int16:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
+                                var iter = slice.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = 0;
+                                Int32 sum = 0;
                                 while (hasNext())
-                                    sum += (int)moveNext();
+                                    sum += (Int32) moveNext();
 
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
+                                var iter = slice.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = 0;
+                                Int64 sum = 0L;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (Int64) moveNext();
 
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
+                                var iter = slice.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = 0;
+                                Single sum = 0f;
                                 while (hasNext())
-                                    sum += (int)moveNext();
+                                    sum += (Single) moveNext();
 
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
+                                var iter = slice.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = 0u;
+                                Double sum = 0d;
                                 while (hasNext())
-                                    sum += (uint)moveNext();
+                                    sum += (Double) moveNext();
 
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(sum/slice.size), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#endif
 
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 0L;
-                                while (hasNext())
-                                    sum += (long)moveNext();
+            if (keepdims)
+                ret.Storage.ExpandDimension(axis);
 
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
+            return ret;
+        }
 
-                            break;
-                        }
+        public T MeanElementwise<T>(NDArray arr, NPTypeCode? typeCode) where T : unmanaged
+        {
+            return (T)Converts.ChangeType(mean_elementwise(arr, typeCode), InfoOf<T>.NPTypeCode);
+        }
 
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
+        protected object mean_elementwise(NDArray arr, NPTypeCode? typeCode)
+        {
+            if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
+                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
 
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
+            var retType = typeCode ?? (arr.GetTypeCode.GetComputingType());
+#if _REGEN1
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    %foreach supported_numericals,supported_numericals_lowercase%
+			    case NPTypeCode.#1: 
+                {
+                    switch (retType)
+		            {
+			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_accumulatingType_defaultvals,supported_numericals_accumulatingType%
+			            case NPTypeCode.#101: 
+                        {
+                            var iter = arr.AsIterator<#2>();
+                            var moveNext = iter.MoveNext;
+                            var hasNext = iter.HasNext;
+                            |#104 sum = #103;
+                            while (hasNext())
+                                sum += (#104) moveNext();
 
-                            break;
+                            return Converts.To#101(sum/arr.size);
                         }
+			            %
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    %
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#else
 
-                        case NPTypeCode.Char:
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    case NPTypeCode.Byte: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = '\0';
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
+                            var iter = arr.AsIterator<byte>();
+                            var moveNext = iter.MoveNext;
+                            var hasNext = iter.HasNext;
+                            Byte sum = 0;
+                            while (hasNext())
+                                sum += (Byte) moveNext();
 
-                            break;
+                            return Converts.ToByte(sum/arr.size);
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int32: 
                         {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 0d;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
+                            var iter = arr.AsIterator<byte>();
+                            var moveNext = iter.MoveNext;
+                            var hasNext = iter.HasNext;
+                            Int32 sum = 0;
+                            while (hasNext())
+                                sum += (Int32) moveNext();
 
-                            break;
+                            return Converts.ToInt32(sum/arr.size);
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Int64: 
                         {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 0f;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
+                            var iter = arr.AsIterator<byte>();
+                            var moveNext = iter.MoveNext;
+                            var hasNext = iter.HasNext;
+                            Int64 sum = 0L;
+                            while (hasNext())
+                                sum += (Int64) moveNext();
 
-                            break;
+                            return Converts.ToInt64(sum/arr.size);
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Single: 
                         {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 0m;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0u;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 0L;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = '\0';
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 0d;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 0f;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 0m;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0u;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 0L;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = '\0';
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 0d;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 0f;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 0m;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0u;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 0L;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = '\0';
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 0d;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 0f;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 0m;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0u;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 0L;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = '\0';
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 0d;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 0f;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 0m;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0u;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 0L;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = '\0';
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 0d;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 0f;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 0m;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0u;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 0L;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = '\0';
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 0d;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 0f;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 0m;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0u;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 0L;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = '\0';
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 0d;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 0f;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 0m;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Decimal:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 0;
-                                while (hasNext())
-                                    sum += (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 0u;
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 0L;
-                                while (hasNext())
-                                    sum += (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 0UL;
-                                while (hasNext())
-                                    sum += (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum / (ulong)slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = '\0';
-                                while (hasNext())
-                                    sum += (uint)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 0d;
-                                while (hasNext())
-                                    sum += (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 0f;
-                                while (hasNext())
-                                    sum += (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 0m;
-                                while (hasNext())
-                                    sum += (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                default:
-                    throw new NotSupportedException();
-            }
-
-            #endregion
-
-#endif
-
-            if (keepdims)
-                ret.Storage.ExpandDimension(axis);
-
-            return ret;
-        }
-
-        public T MeanElementwise<T>(NDArray arr, NPTypeCode? typeCode) where T : unmanaged
-        {
-            return (T)Converts.ChangeType(mean_elementwise(arr, typeCode), InfoOf<T>.NPTypeCode);
-        }
-
-        protected object mean_elementwise(NDArray arr, NPTypeCode? typeCode)
-        {
-            if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
-                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
-
-            var retType = typeCode ?? (arr.GetTypeCode.GetComputingType());
-#if _REGEN
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    %foreach supported_numericals,supported_numericals_lowercase%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_accumulatingType_defaultvals,supported_numericals_accumulatingType%
-			            case NPTypeCode.#101: 
-                        {
-                            var iter = arr.AsIterator<#2>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            |#104 sum = #103;
-                            while (hasNext())
-                                sum += (#104) moveNext();
-
-                            return Converts.To#101(sum/arr.size);
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    %
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#else
-
-            #region Compute
-
-            switch (arr.GetTypeCode)
-            {
-                case NPTypeCode.Byte:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0u;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 0L;
-                            while (hasNext())
-                                sum += (long)moveNext();
-
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
-                            while (hasNext())
-                                sum += (ulong)moveNext();
-
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = '\0';
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToChar(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 0d;
-                            while (hasNext())
-                                sum += (double)moveNext();
-
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 0f;
-                            while (hasNext())
-                                sum += (float)moveNext();
-
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 0m;
-                            while (hasNext())
-                                sum += (decimal)moveNext();
-
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0u;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 0L;
-                            while (hasNext())
-                                sum += (long)moveNext();
-
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
-                            while (hasNext())
-                                sum += (ulong)moveNext();
-
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = '\0';
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToChar(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 0d;
-                            while (hasNext())
-                                sum += (double)moveNext();
-
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 0f;
-                            while (hasNext())
-                                sum += (float)moveNext();
-
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 0m;
-                            while (hasNext())
-                                sum += (decimal)moveNext();
-
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0u;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 0L;
-                            while (hasNext())
-                                sum += (long)moveNext();
-
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
-                            while (hasNext())
-                                sum += (ulong)moveNext();
-
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = '\0';
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToChar(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 0d;
-                            while (hasNext())
-                                sum += (double)moveNext();
-
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 0f;
-                            while (hasNext())
-                                sum += (float)moveNext();
-
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 0m;
-                            while (hasNext())
-                                sum += (decimal)moveNext();
-
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0u;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 0L;
-                            while (hasNext())
-                                sum += (long)moveNext();
-
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
-                            while (hasNext())
-                                sum += (ulong)moveNext();
-
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = '\0';
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToChar(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 0d;
-                            while (hasNext())
-                                sum += (double)moveNext();
-
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 0f;
-                            while (hasNext())
-                                sum += (float)moveNext();
-
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 0m;
-                            while (hasNext())
-                                sum += (decimal)moveNext();
-
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0u;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 0L;
-                            while (hasNext())
-                                sum += (long)moveNext();
-
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
-                            while (hasNext())
-                                sum += (ulong)moveNext();
-
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = '\0';
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToChar(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 0d;
-                            while (hasNext())
-                                sum += (double)moveNext();
-
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 0f;
-                            while (hasNext())
-                                sum += (float)moveNext();
-
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 0m;
-                            while (hasNext())
-                                sum += (decimal)moveNext();
-
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0u;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 0L;
-                            while (hasNext())
-                                sum += (long)moveNext();
-
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
-                            while (hasNext())
-                                sum += (ulong)moveNext();
-
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = '\0';
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToChar(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 0d;
-                            while (hasNext())
-                                sum += (double)moveNext();
-
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 0f;
-                            while (hasNext())
-                                sum += (float)moveNext();
-
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 0m;
-                            while (hasNext())
-                                sum += (decimal)moveNext();
-
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0u;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 0L;
-                            while (hasNext())
-                                sum += (long)moveNext();
-
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
-                            while (hasNext())
-                                sum += (ulong)moveNext();
-
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = '\0';
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToChar(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 0d;
-                            while (hasNext())
-                                sum += (double)moveNext();
-
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 0f;
-                            while (hasNext())
-                                sum += (float)moveNext();
-
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 0m;
-                            while (hasNext())
-                                sum += (decimal)moveNext();
-
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0u;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 0L;
-                            while (hasNext())
-                                sum += (long)moveNext();
-
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
-                            while (hasNext())
-                                sum += (ulong)moveNext();
-
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = '\0';
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToChar(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 0d;
-                            while (hasNext())
-                                sum += (double)moveNext();
-
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            float sum = 0f;
+                            Single sum = 0f;
                             while (hasNext())
-                                sum += (float)moveNext();
+                                sum += (Single) moveNext();
 
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
+                            return Converts.ToSingle(sum/arr.size);
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal sum = 0m;
+                            Double sum = 0d;
                             while (hasNext())
-                                sum += (decimal)moveNext();
+                                sum += (Double) moveNext();
 
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
+                            return Converts.ToDouble(sum/arr.size);
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Double:
+			    case NPTypeCode.Int32: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0u;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 0L;
-                            while (hasNext())
-                                sum += (long)moveNext();
-
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
+                            Byte sum = 0;
                             while (hasNext())
-                                sum += (ulong)moveNext();
+                                sum += (Byte) moveNext();
 
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
+                            return Converts.ToByte(sum/arr.size);
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            uint sum = '\0';
+                            Int32 sum = 0;
                             while (hasNext())
-                                sum += (uint)moveNext();
+                                sum += (Int32) moveNext();
 
-                            return Converts.ToChar(sum / arr.size);
-                            break;
+                            return Converts.ToInt32(sum/arr.size);
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            double sum = 0d;
+                            Int64 sum = 0L;
                             while (hasNext())
-                                sum += (double)moveNext();
+                                sum += (Int64) moveNext();
 
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
+                            return Converts.ToInt64(sum/arr.size);
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            float sum = 0f;
+                            Single sum = 0f;
                             while (hasNext())
-                                sum += (float)moveNext();
+                                sum += (Single) moveNext();
 
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
+                            return Converts.ToSingle(sum/arr.size);
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal sum = 0m;
+                            Double sum = 0d;
                             while (hasNext())
-                                sum += (decimal)moveNext();
+                                sum += (Double) moveNext();
 
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
+                            return Converts.ToDouble(sum/arr.size);
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Single:
+			    case NPTypeCode.Int64: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            int sum = 0;
+                            Byte sum = 0;
                             while (hasNext())
-                                sum += (int)moveNext();
+                                sum += (Byte) moveNext();
 
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
+                            return Converts.ToByte(sum/arr.size);
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            uint sum = 0;
+                            Int32 sum = 0;
                             while (hasNext())
-                                sum += (uint)moveNext();
+                                sum += (Int32) moveNext();
 
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
+                            return Converts.ToInt32(sum/arr.size);
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            int sum = 0;
+                            Int64 sum = 0L;
                             while (hasNext())
-                                sum += (int)moveNext();
+                                sum += (Int64) moveNext();
 
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
+                            return Converts.ToInt64(sum/arr.size);
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            uint sum = 0u;
+                            Single sum = 0f;
                             while (hasNext())
-                                sum += (uint)moveNext();
+                                sum += (Single) moveNext();
 
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
+                            return Converts.ToSingle(sum/arr.size);
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            long sum = 0L;
+                            Double sum = 0d;
                             while (hasNext())
-                                sum += (long)moveNext();
+                                sum += (Double) moveNext();
 
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
+                            return Converts.ToDouble(sum/arr.size);
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
+                            Byte sum = 0;
                             while (hasNext())
-                                sum += (ulong)moveNext();
+                                sum += (Byte) moveNext();
 
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
+                            return Converts.ToByte(sum/arr.size);
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            uint sum = '\0';
+                            Int32 sum = 0;
                             while (hasNext())
-                                sum += (uint)moveNext();
+                                sum += (Int32) moveNext();
 
-                            return Converts.ToChar(sum / arr.size);
-                            break;
+                            return Converts.ToInt32(sum/arr.size);
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            double sum = 0d;
+                            Int64 sum = 0L;
                             while (hasNext())
-                                sum += (double)moveNext();
+                                sum += (Int64) moveNext();
 
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
+                            return Converts.ToInt64(sum/arr.size);
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            float sum = 0f;
+                            Single sum = 0f;
                             while (hasNext())
-                                sum += (float)moveNext();
+                                sum += (Single) moveNext();
 
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
+                            return Converts.ToSingle(sum/arr.size);
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal sum = 0m;
+                            Double sum = 0d;
                             while (hasNext())
-                                sum += (decimal)moveNext();
+                                sum += (Double) moveNext();
 
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
+                            return Converts.ToDouble(sum/arr.size);
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Decimal:
+			    case NPTypeCode.Double: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToByte(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt16(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 0;
-                            while (hasNext())
-                                sum += (int)moveNext();
-
-                            return Converts.ToInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 0u;
-                            while (hasNext())
-                                sum += (uint)moveNext();
-
-                            return Converts.ToUInt32(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 0L;
-                            while (hasNext())
-                                sum += (long)moveNext();
-
-                            return Converts.ToInt64(sum / arr.size);
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            ulong sum = 0UL;
+                            Byte sum = 0;
                             while (hasNext())
-                                sum += (ulong)moveNext();
+                                sum += (Byte) moveNext();
 
-                            return Converts.ToUInt64(sum / (ulong)arr.size);
-                            break;
+                            return Converts.ToByte(sum/arr.size);
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            uint sum = '\0';
+                            Int32 sum = 0;
                             while (hasNext())
-                                sum += (uint)moveNext();
+                                sum += (Int32) moveNext();
 
-                            return Converts.ToChar(sum / arr.size);
-                            break;
+                            return Converts.ToInt32(sum/arr.size);
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            double sum = 0d;
+                            Int64 sum = 0L;
                             while (hasNext())
-                                sum += (double)moveNext();
+                                sum += (Int64) moveNext();
 
-                            return Converts.ToDouble(sum / arr.size);
-                            break;
+                            return Converts.ToInt64(sum/arr.size);
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            float sum = 0f;
+                            Single sum = 0f;
                             while (hasNext())
-                                sum += (float)moveNext();
+                                sum += (Single) moveNext();
 
-                            return Converts.ToSingle(sum / arr.size);
-                            break;
+                            return Converts.ToSingle(sum/arr.size);
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal sum = 0m;
+                            Double sum = 0d;
                             while (hasNext())
-                                sum += (decimal)moveNext();
+                                sum += (Double) moveNext();
 
-                            return Converts.ToDecimal(sum / arr.size);
-                            break;
+                            return Converts.ToDouble(sum/arr.size);
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                default:
-                    throw new NotSupportedException();
-            }
-
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
     }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Product.cs b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Product.cs
index 1b5836b9f..0a710d61f 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Product.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Product.cs
@@ -62,7 +62,7 @@ public override NDArray ReduceProduct(NDArray arr, int? axis_, bool keepdims = f
 
             //resolve the accumulator type
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -102,14 +102,13 @@ public override NDArray ReduceProduct(NDArray arr, int? axis_, bool keepdims = f
 #else
 
             #region Compute
-
             switch (arr.GetTypeCode)
-            {
-                case NPTypeCode.Byte:
+		    {
+			    case NPTypeCode.Byte: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
@@ -119,33 +118,13 @@ public override NDArray ReduceProduct(NDArray arr, int? axis_, bool keepdims = f
                                 var hasNext = iter.HasNext;
                                 byte sum = 1;
                                 while (hasNext())
-                                    sum *= (byte)moveNext();
+                                    sum *= (byte) moveNext();
 
                                 ret.SetByte(Converts.ToByte(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
@@ -153,17 +132,15 @@ public override NDArray ReduceProduct(NDArray arr, int? axis_, bool keepdims = f
                                 var iter = slice.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ushort sum = 1;
+                                int sum = 1;
                                 while (hasNext())
-                                    sum *= (ushort)moveNext();
+                                    sum *= (int) moveNext();
 
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
@@ -171,17 +148,15 @@ public override NDArray ReduceProduct(NDArray arr, int? axis_, bool keepdims = f
                                 var iter = slice.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = 1;
+                                long sum = 1L;
                                 while (hasNext())
-                                    sum *= (int)moveNext();
+                                    sum *= (long) moveNext();
 
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
@@ -189,17 +164,15 @@ public override NDArray ReduceProduct(NDArray arr, int? axis_, bool keepdims = f
                                 var iter = slice.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = 1u;
+                                float sum = 1f;
                                 while (hasNext())
-                                    sum *= (uint)moveNext();
+                                    sum *= (float) moveNext();
 
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
@@ -207,3847 +180,761 @@ public override NDArray ReduceProduct(NDArray arr, int? axis_, bool keepdims = f
                                 var iter = slice.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long sum = 1L;
+                                double sum = 1d;
                                 while (hasNext())
-                                    sum *= (long)moveNext();
+                                    sum *= (double) moveNext();
 
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int32: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
+                                var iter = slice.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
+                                byte sum = 1;
                                 while (hasNext())
-                                    sum *= (ulong)moveNext();
+                                    sum *= (byte) moveNext();
 
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
+                                ret.SetByte(Converts.ToByte(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
+                                var iter = slice.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                char sum = '1';
+                                int sum = 1;
                                 while (hasNext())
-                                    sum *= (char)moveNext();
+                                    sum *= (int) moveNext();
 
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
+                                var iter = slice.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                double sum = 1d;
+                                long sum = 1L;
                                 while (hasNext())
-                                    sum *= (double)moveNext();
+                                    sum *= (long) moveNext();
 
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
+                                var iter = slice.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 float sum = 1f;
                                 while (hasNext())
-                                    sum *= (float)moveNext();
+                                    sum *= (float) moveNext();
 
                                 ret.SetSingle(Converts.ToSingle(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<byte>();
+                                var iter = slice.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal sum = 1m;
+                                double sum = 1d;
                                 while (hasNext())
-                                    sum *= (decimal)moveNext();
+                                    sum *= (double) moveNext();
 
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Int16:
+			    case NPTypeCode.Int64: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 byte sum = 1;
                                 while (hasNext())
-                                    sum *= (byte)moveNext();
+                                    sum *= (byte) moveNext();
 
                                 ret.SetByte(Converts.ToByte(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ushort sum = 1;
+                                int sum = 1;
                                 while (hasNext())
-                                    sum *= (ushort)moveNext();
+                                    sum *= (int) moveNext();
 
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                int sum = 1;
+                                long sum = 1L;
                                 while (hasNext())
-                                    sum *= (int)moveNext();
+                                    sum *= (long) moveNext();
 
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                uint sum = 1u;
+                                float sum = 1f;
                                 while (hasNext())
-                                    sum *= (uint)moveNext();
+                                    sum *= (float) moveNext();
 
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                long sum = 1L;
+                                double sum = 1d;
                                 while (hasNext())
-                                    sum *= (long)moveNext();
+                                    sum *= (double) moveNext();
 
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
+                                byte sum = 1;
                                 while (hasNext())
-                                    sum *= (ulong)moveNext();
+                                    sum *= (byte) moveNext();
 
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
+                                ret.SetByte(Converts.ToByte(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                char sum = '1';
+                                int sum = 1;
                                 while (hasNext())
-                                    sum *= (char)moveNext();
+                                    sum *= (int) moveNext();
 
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
+                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                double sum = 1d;
+                                long sum = 1L;
                                 while (hasNext())
-                                    sum *= (double)moveNext();
+                                    sum *= (long) moveNext();
 
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
+                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 float sum = 1f;
                                 while (hasNext())
-                                    sum *= (float)moveNext();
+                                    sum *= (float) moveNext();
 
                                 ret.SetSingle(Converts.ToSingle(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<short>();
+                                var iter = slice.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                decimal sum = 1m;
+                                double sum = 1d;
                                 while (hasNext())
-                                    sum *= (decimal)moveNext();
+                                    sum *= (double) moveNext();
 
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
+                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.UInt16:
+			    case NPTypeCode.Double: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
+                                var iter = slice.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 byte sum = 1;
                                 while (hasNext())
-                                    sum *= (byte)moveNext();
+                                    sum *= (byte) moveNext();
 
                                 ret.SetByte(Converts.ToByte(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = 1;
-                                while (hasNext())
-                                    sum *= (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int32: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
+                                var iter = slice.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 int sum = 1;
                                 while (hasNext())
-                                    sum *= (int)moveNext();
+                                    sum *= (int) moveNext();
 
                                 ret.SetInt32(Converts.ToInt32(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 1u;
-                                while (hasNext())
-                                    sum *= (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Int64: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
+                                var iter = slice.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 long sum = 1L;
                                 while (hasNext())
-                                    sum *= (long)moveNext();
+                                    sum *= (long) moveNext();
 
                                 ret.SetInt64(Converts.ToInt64(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
-                                while (hasNext())
-                                    sum *= (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Single: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
+                                var iter = slice.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                char sum = '1';
+                                float sum = 1f;
                                 while (hasNext())
-                                    sum *= (char)moveNext();
+                                    sum *= (float) moveNext();
 
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
+                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Double: 
                         {
                             do
                             {
                                 var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
+                                var iter = slice.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 double sum = 1d;
                                 while (hasNext())
-                                    sum *= (double)moveNext();
+                                    sum *= (double) moveNext();
 
                                 ret.SetDouble(Converts.ToDouble(sum), iterIndex);
                             } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                             break;
                         }
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#endif
 
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 1f;
-                                while (hasNext())
-                                    sum *= (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
+            if (keepdims)
+                ret.Storage.ExpandDimension(axis);
+            else if (ret.Shape.size == 1 && ret.ndim == 1)
+                ret.Storage.Reshape(Shape.Scalar);
 
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 1m;
-                                while (hasNext())
-                                    sum *= (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = 1;
-                                while (hasNext())
-                                    sum *= (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = 1;
-                                while (hasNext())
-                                    sum *= (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 1;
-                                while (hasNext())
-                                    sum *= (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 1u;
-                                while (hasNext())
-                                    sum *= (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 1L;
-                                while (hasNext())
-                                    sum *= (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
-                                while (hasNext())
-                                    sum *= (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = '1';
-                                while (hasNext())
-                                    sum *= (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 1d;
-                                while (hasNext())
-                                    sum *= (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 1f;
-                                while (hasNext())
-                                    sum *= (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 1m;
-                                while (hasNext())
-                                    sum *= (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = 1;
-                                while (hasNext())
-                                    sum *= (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = 1;
-                                while (hasNext())
-                                    sum *= (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 1;
-                                while (hasNext())
-                                    sum *= (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 1u;
-                                while (hasNext())
-                                    sum *= (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 1L;
-                                while (hasNext())
-                                    sum *= (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
-                                while (hasNext())
-                                    sum *= (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = '1';
-                                while (hasNext())
-                                    sum *= (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 1d;
-                                while (hasNext())
-                                    sum *= (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 1f;
-                                while (hasNext())
-                                    sum *= (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 1m;
-                                while (hasNext())
-                                    sum *= (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = 1;
-                                while (hasNext())
-                                    sum *= (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = 1;
-                                while (hasNext())
-                                    sum *= (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 1;
-                                while (hasNext())
-                                    sum *= (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 1u;
-                                while (hasNext())
-                                    sum *= (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 1L;
-                                while (hasNext())
-                                    sum *= (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
-                                while (hasNext())
-                                    sum *= (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = '1';
-                                while (hasNext())
-                                    sum *= (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 1d;
-                                while (hasNext())
-                                    sum *= (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 1f;
-                                while (hasNext())
-                                    sum *= (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 1m;
-                                while (hasNext())
-                                    sum *= (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = 1;
-                                while (hasNext())
-                                    sum *= (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = 1;
-                                while (hasNext())
-                                    sum *= (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 1;
-                                while (hasNext())
-                                    sum *= (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 1u;
-                                while (hasNext())
-                                    sum *= (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 1L;
-                                while (hasNext())
-                                    sum *= (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
-                                while (hasNext())
-                                    sum *= (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = '1';
-                                while (hasNext())
-                                    sum *= (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 1d;
-                                while (hasNext())
-                                    sum *= (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 1f;
-                                while (hasNext())
-                                    sum *= (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 1m;
-                                while (hasNext())
-                                    sum *= (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = 1;
-                                while (hasNext())
-                                    sum *= (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = 1;
-                                while (hasNext())
-                                    sum *= (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 1;
-                                while (hasNext())
-                                    sum *= (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 1u;
-                                while (hasNext())
-                                    sum *= (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 1L;
-                                while (hasNext())
-                                    sum *= (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
-                                while (hasNext())
-                                    sum *= (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = '1';
-                                while (hasNext())
-                                    sum *= (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 1d;
-                                while (hasNext())
-                                    sum *= (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 1f;
-                                while (hasNext())
-                                    sum *= (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 1m;
-                                while (hasNext())
-                                    sum *= (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = 1;
-                                while (hasNext())
-                                    sum *= (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = 1;
-                                while (hasNext())
-                                    sum *= (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 1;
-                                while (hasNext())
-                                    sum *= (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 1u;
-                                while (hasNext())
-                                    sum *= (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 1L;
-                                while (hasNext())
-                                    sum *= (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
-                                while (hasNext())
-                                    sum *= (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = '1';
-                                while (hasNext())
-                                    sum *= (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 1d;
-                                while (hasNext())
-                                    sum *= (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 1f;
-                                while (hasNext())
-                                    sum *= (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 1m;
-                                while (hasNext())
-                                    sum *= (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = 1;
-                                while (hasNext())
-                                    sum *= (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = 1;
-                                while (hasNext())
-                                    sum *= (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 1;
-                                while (hasNext())
-                                    sum *= (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 1u;
-                                while (hasNext())
-                                    sum *= (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 1L;
-                                while (hasNext())
-                                    sum *= (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
-                                while (hasNext())
-                                    sum *= (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = '1';
-                                while (hasNext())
-                                    sum *= (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 1d;
-                                while (hasNext())
-                                    sum *= (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 1f;
-                                while (hasNext())
-                                    sum *= (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 1m;
-                                while (hasNext())
-                                    sum *= (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Decimal:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                byte sum = 1;
-                                while (hasNext())
-                                    sum *= (byte)moveNext();
-
-                                ret.SetByte(Converts.ToByte(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                short sum = 1;
-                                while (hasNext())
-                                    sum *= (short)moveNext();
-
-                                ret.SetInt16(Converts.ToInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ushort sum = 1;
-                                while (hasNext())
-                                    sum *= (ushort)moveNext();
-
-                                ret.SetUInt16(Converts.ToUInt16(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                int sum = 1;
-                                while (hasNext())
-                                    sum *= (int)moveNext();
-
-                                ret.SetInt32(Converts.ToInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                uint sum = 1u;
-                                while (hasNext())
-                                    sum *= (uint)moveNext();
-
-                                ret.SetUInt32(Converts.ToUInt32(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                long sum = 1L;
-                                while (hasNext())
-                                    sum *= (long)moveNext();
-
-                                ret.SetInt64(Converts.ToInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                ulong sum = 1UL;
-                                while (hasNext())
-                                    sum *= (ulong)moveNext();
-
-                                ret.SetUInt64(Converts.ToUInt64(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                char sum = '1';
-                                while (hasNext())
-                                    sum *= (char)moveNext();
-
-                                ret.SetChar(Converts.ToChar(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                double sum = 1d;
-                                while (hasNext())
-                                    sum *= (double)moveNext();
-
-                                ret.SetDouble(Converts.ToDouble(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                float sum = 1f;
-                                while (hasNext())
-                                    sum *= (float)moveNext();
-
-                                ret.SetSingle(Converts.ToSingle(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            do
-                            {
-                                var slice = arr[slices];
-                                var iter = slice.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                decimal sum = 1m;
-                                while (hasNext())
-                                    sum *= (decimal)moveNext();
-
-                                ret.SetDecimal(Converts.ToDecimal(sum), iterIndex);
-                            } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                default:
-                    throw new NotSupportedException();
-            }
-
-            #endregion
-
-#endif
-
-            if (keepdims)
-                ret.Storage.ExpandDimension(axis);
-            else if (ret.Shape.size == 1 && ret.ndim == 1)
-                ret.Storage.Reshape(Shape.Scalar);
-
-            return ret;
-        }
-
-        public T ProductElementwise<T>(NDArray arr, NPTypeCode? typeCode) where T : unmanaged
-        {
-            return Converts.ChangeType<T>(product_elementwise(arr, typeCode));
-        }
-
-        protected object product_elementwise(NDArray arr, NPTypeCode? typeCode)
-        {
-            if (arr.Shape.IsScalar || (arr.Shape.NDim == 1 && arr.Shape.size == 1))
-                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
-
-            var retType = typeCode ?? (arr.GetTypeCode.GetAccumulatingType());
-#if _REGEN
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    %foreach supported_numericals,supported_numericals_lowercase%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
-			            case NPTypeCode.#101: 
-                        {
-                            var iter = arr.AsIterator<#2>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            |#102 sum = #103;
-                            while (hasNext())
-                                sum *= (#102) moveNext();
-
-                            return sum;
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    %
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#else
-
-            #region Compute
-
-            switch (arr.GetTypeCode)
-            {
-                case NPTypeCode.Byte:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte sum = 1;
-                            while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort sum = 1;
-                            while (hasNext())
-                                sum *= (ushort)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 1;
-                            while (hasNext())
-                                sum *= (int)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 1u;
-                            while (hasNext())
-                                sum *= (uint)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 1L;
-                            while (hasNext())
-                                sum *= (long)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
-                            while (hasNext())
-                                sum *= (ulong)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char sum = '1';
-                            while (hasNext())
-                                sum *= (char)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 1d;
-                            while (hasNext())
-                                sum *= (double)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 1f;
-                            while (hasNext())
-                                sum *= (float)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<byte>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 1m;
-                            while (hasNext())
-                                sum *= (decimal)moveNext();
-
-                            return sum;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte sum = 1;
-                            while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort sum = 1;
-                            while (hasNext())
-                                sum *= (ushort)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 1;
-                            while (hasNext())
-                                sum *= (int)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 1u;
-                            while (hasNext())
-                                sum *= (uint)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 1L;
-                            while (hasNext())
-                                sum *= (long)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
-                            while (hasNext())
-                                sum *= (ulong)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char sum = '1';
-                            while (hasNext())
-                                sum *= (char)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 1d;
-                            while (hasNext())
-                                sum *= (double)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 1f;
-                            while (hasNext())
-                                sum *= (float)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<short>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 1m;
-                            while (hasNext())
-                                sum *= (decimal)moveNext();
-
-                            return sum;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte sum = 1;
-                            while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort sum = 1;
-                            while (hasNext())
-                                sum *= (ushort)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 1;
-                            while (hasNext())
-                                sum *= (int)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 1u;
-                            while (hasNext())
-                                sum *= (uint)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 1L;
-                            while (hasNext())
-                                sum *= (long)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
-                            while (hasNext())
-                                sum *= (ulong)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char sum = '1';
-                            while (hasNext())
-                                sum *= (char)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 1d;
-                            while (hasNext())
-                                sum *= (double)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 1f;
-                            while (hasNext())
-                                sum *= (float)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<ushort>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 1m;
-                            while (hasNext())
-                                sum *= (decimal)moveNext();
-
-                            return sum;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte sum = 1;
-                            while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort sum = 1;
-                            while (hasNext())
-                                sum *= (ushort)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 1;
-                            while (hasNext())
-                                sum *= (int)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 1u;
-                            while (hasNext())
-                                sum *= (uint)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 1L;
-                            while (hasNext())
-                                sum *= (long)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
-                            while (hasNext())
-                                sum *= (ulong)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char sum = '1';
-                            while (hasNext())
-                                sum *= (char)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 1d;
-                            while (hasNext())
-                                sum *= (double)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 1f;
-                            while (hasNext())
-                                sum *= (float)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<int>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 1m;
-                            while (hasNext())
-                                sum *= (decimal)moveNext();
-
-                            return sum;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte sum = 1;
-                            while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort sum = 1;
-                            while (hasNext())
-                                sum *= (ushort)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 1;
-                            while (hasNext())
-                                sum *= (int)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 1u;
-                            while (hasNext())
-                                sum *= (uint)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 1L;
-                            while (hasNext())
-                                sum *= (long)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
-                            while (hasNext())
-                                sum *= (ulong)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char sum = '1';
-                            while (hasNext())
-                                sum *= (char)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 1d;
-                            while (hasNext())
-                                sum *= (double)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 1f;
-                            while (hasNext())
-                                sum *= (float)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<uint>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 1m;
-                            while (hasNext())
-                                sum *= (decimal)moveNext();
-
-                            return sum;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte sum = 1;
-                            while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort sum = 1;
-                            while (hasNext())
-                                sum *= (ushort)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 1;
-                            while (hasNext())
-                                sum *= (int)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 1u;
-                            while (hasNext())
-                                sum *= (uint)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 1L;
-                            while (hasNext())
-                                sum *= (long)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
-                            while (hasNext())
-                                sum *= (ulong)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char sum = '1';
-                            while (hasNext())
-                                sum *= (char)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 1d;
-                            while (hasNext())
-                                sum *= (double)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 1f;
-                            while (hasNext())
-                                sum *= (float)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<long>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 1m;
-                            while (hasNext())
-                                sum *= (decimal)moveNext();
-
-                            return sum;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte sum = 1;
-                            while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort sum = 1;
-                            while (hasNext())
-                                sum *= (ushort)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 1;
-                            while (hasNext())
-                                sum *= (int)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 1u;
-                            while (hasNext())
-                                sum *= (uint)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            long sum = 1L;
-                            while (hasNext())
-                                sum *= (long)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
-                            while (hasNext())
-                                sum *= (ulong)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char sum = '1';
-                            while (hasNext())
-                                sum *= (char)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 1d;
-                            while (hasNext())
-                                sum *= (double)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            float sum = 1f;
-                            while (hasNext())
-                                sum *= (float)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            var iter = arr.AsIterator<ulong>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            decimal sum = 1m;
-                            while (hasNext())
-                                sum *= (decimal)moveNext();
-
-                            return sum;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            byte sum = 1;
-                            while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort sum = 1;
-                            while (hasNext())
-                                sum *= (ushort)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            int sum = 1;
-                            while (hasNext())
-                                sum *= (int)moveNext();
-
-                            return sum;
-                        }
+            return ret;
+        }
 
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<char>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 1u;
-                            while (hasNext())
-                                sum *= (uint)moveNext();
+        public T ProductElementwise<T>(NDArray arr, NPTypeCode? typeCode) where T : unmanaged
+        {
+            return Converts.ChangeType<T>(product_elementwise(arr, typeCode));
+        }
 
-                            return sum;
-                        }
+        protected object product_elementwise(NDArray arr, NPTypeCode? typeCode)
+        {
+            if (arr.Shape.IsScalar || (arr.Shape.NDim == 1 && arr.Shape.size == 1))
+                return typeCode.HasValue ? Cast(arr, typeCode.Value, true) : arr.Clone();
 
-                        case NPTypeCode.Int64:
+            var retType = typeCode ?? (arr.GetTypeCode.GetAccumulatingType());
+#if _REGEN1
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    %foreach supported_numericals,supported_numericals_lowercase%
+			    case NPTypeCode.#1: 
+                {
+                    switch (retType)
+		            {
+			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
+			            case NPTypeCode.#101: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<#2>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            long sum = 1L;
+                            |#102 sum = #103;
                             while (hasNext())
-                                sum *= (long)moveNext();
+                                sum *= (#102) moveNext();
 
                             return sum;
                         }
+			            %
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    %
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#else
 
-                        case NPTypeCode.UInt64:
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    case NPTypeCode.Byte: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
+                            byte sum = 1;
                             while (hasNext())
-                                sum *= (ulong)moveNext();
+                                sum *= (byte) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            char sum = '1';
+                            int sum = 1;
                             while (hasNext())
-                                sum *= (char)moveNext();
+                                sum *= (int) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            double sum = 1d;
+                            long sum = 1L;
                             while (hasNext())
-                                sum *= (double)moveNext();
+                                sum *= (long) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             float sum = 1f;
                             while (hasNext())
-                                sum *= (float)moveNext();
+                                sum *= (float) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<char>();
+                            var iter = arr.AsIterator<byte>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal sum = 1m;
+                            double sum = 1d;
                             while (hasNext())
-                                sum *= (decimal)moveNext();
+                                sum *= (double) moveNext();
 
                             return sum;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Double:
+			    case NPTypeCode.Int32: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte sum = 1;
                             while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort sum = 1;
-                            while (hasNext())
-                                sum *= (ushort)moveNext();
+                                sum *= (byte) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int sum = 1;
                             while (hasNext())
-                                sum *= (int)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 1u;
-                            while (hasNext())
-                                sum *= (uint)moveNext();
+                                sum *= (int) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             long sum = 1L;
                             while (hasNext())
-                                sum *= (long)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
-                            while (hasNext())
-                                sum *= (ulong)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char sum = '1';
-                            while (hasNext())
-                                sum *= (char)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<double>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 1d;
-                            while (hasNext())
-                                sum *= (double)moveNext();
+                                sum *= (long) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             float sum = 1f;
                             while (hasNext())
-                                sum *= (float)moveNext();
+                                sum *= (float) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<double>();
+                            var iter = arr.AsIterator<int>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal sum = 1m;
+                            double sum = 1d;
                             while (hasNext())
-                                sum *= (decimal)moveNext();
+                                sum *= (double) moveNext();
 
                             return sum;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Single:
+			    case NPTypeCode.Int64: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte sum = 1;
                             while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<float>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
+                                sum *= (byte) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            ushort sum = 1;
+                            int sum = 1;
                             while (hasNext())
-                                sum *= (ushort)moveNext();
+                                sum *= (int) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            int sum = 1;
+                            long sum = 1L;
                             while (hasNext())
-                                sum *= (int)moveNext();
+                                sum *= (long) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            uint sum = 1u;
+                            float sum = 1f;
                             while (hasNext())
-                                sum *= (uint)moveNext();
+                                sum *= (float) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<float>();
+                            var iter = arr.AsIterator<long>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            long sum = 1L;
+                            double sum = 1d;
                             while (hasNext())
-                                sum *= (long)moveNext();
+                                sum *= (double) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
+                            byte sum = 1;
                             while (hasNext())
-                                sum *= (ulong)moveNext();
+                                sum *= (byte) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            char sum = '1';
+                            int sum = 1;
                             while (hasNext())
-                                sum *= (char)moveNext();
+                                sum *= (int) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            double sum = 1d;
+                            long sum = 1L;
                             while (hasNext())
-                                sum *= (double)moveNext();
+                                sum *= (long) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             float sum = 1f;
                             while (hasNext())
-                                sum *= (float)moveNext();
+                                sum *= (float) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
                             var iter = arr.AsIterator<float>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal sum = 1m;
+                            double sum = 1d;
                             while (hasNext())
-                                sum *= (decimal)moveNext();
+                                sum *= (double) moveNext();
 
                             return sum;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Decimal:
+			    case NPTypeCode.Double: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             byte sum = 1;
                             while (hasNext())
-                                sum *= (byte)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            short sum = 1;
-                            while (hasNext())
-                                sum *= (short)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ushort sum = 1;
-                            while (hasNext())
-                                sum *= (ushort)moveNext();
+                                sum *= (byte) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int32: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             int sum = 1;
                             while (hasNext())
-                                sum *= (int)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            uint sum = 1u;
-                            while (hasNext())
-                                sum *= (uint)moveNext();
+                                sum *= (int) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Int64: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             long sum = 1L;
                             while (hasNext())
-                                sum *= (long)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            ulong sum = 1UL;
-                            while (hasNext())
-                                sum *= (ulong)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            char sum = '1';
-                            while (hasNext())
-                                sum *= (char)moveNext();
-
-                            return sum;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            var iter = arr.AsIterator<decimal>();
-                            var moveNext = iter.MoveNext;
-                            var hasNext = iter.HasNext;
-                            double sum = 1d;
-                            while (hasNext())
-                                sum *= (double)moveNext();
+                                sum *= (long) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
                             float sum = 1f;
                             while (hasNext())
-                                sum *= (float)moveNext();
+                                sum *= (float) moveNext();
 
                             return sum;
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            var iter = arr.AsIterator<decimal>();
+                            var iter = arr.AsIterator<double>();
                             var moveNext = iter.MoveNext;
                             var hasNext = iter.HasNext;
-                            decimal sum = 1m;
+                            double sum = 1d;
                             while (hasNext())
-                                sum *= (decimal)moveNext();
+                                sum *= (double) moveNext();
 
                             return sum;
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                default:
-                    throw new NotSupportedException();
-            }
-
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
     }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Std.cs b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Std.cs
index 33cd6963f..1e0ddc001 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Std.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Std.cs
@@ -59,7 +59,7 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
 
             //resolve the accumulator type
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -178,17 +178,15 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
 #else
 
             #region Compute
-
             switch (arr.GetTypeCode)
-            {
-                case NPTypeCode.Byte:
+		    {
+			    case NPTypeCode.Byte: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
@@ -199,19 +197,15 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
                                     ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
@@ -221,23 +215,19 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
                                     ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Int16:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
@@ -248,19 +238,15 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
@@ -270,23 +256,19 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
@@ -297,19 +279,15 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
@@ -319,23 +297,19 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
@@ -346,19 +320,15 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
@@ -368,23 +338,19 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
@@ -395,19 +361,15 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
@@ -417,9915 +379,1708 @@ public override NDArray ReduceStd(NDArray arr, int? axis_, bool keepdims = false
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Int64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int32: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.UInt64:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Decimal:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int64: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Int16:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.UInt32:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.UInt64:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
                                     ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
                                     ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Single:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Double: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Int16:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
 
                                     double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
                                 break;
                             }
                         }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Decimal: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
+                        {                            
+                            if (ddof.HasValue) {
+                                var _ddof = (decimal) ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<decimal>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
+                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
 
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    decimal sum = 0;
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetByte(Converts.ToByte(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<decimal>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
+                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
 
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    decimal sum = 0;
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetByte(Converts.ToByte(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
                             }
+                            break;
                         }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
+			            case NPTypeCode.Int32: 
+                        {                            
+                            if (ddof.HasValue) {
+                                var _ddof = (decimal) ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<decimal>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
+                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
 
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    decimal sum = 0;
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<decimal>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
+                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
 
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    decimal sum = 0;
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
                             }
+                            break;
                         }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
+			            case NPTypeCode.Int64: 
+                        {                            
+                            if (ddof.HasValue) {
+                                var _ddof = (decimal) ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<decimal>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
+                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
 
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    decimal sum = 0;
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<decimal>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
+                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
 
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    decimal sum = 0;
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
                             }
+                            break;
                         }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
+			            case NPTypeCode.Single: 
+                        {                            
+                            if (ddof.HasValue) {
+                                var _ddof = (decimal) ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<decimal>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
+                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
 
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    decimal sum = 0;
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<decimal>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
+                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
 
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    decimal sum = 0;
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
                             }
+                            break;
                         }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
+			            case NPTypeCode.Double: 
+                        {                            
+                            if (ddof.HasValue) {
+                                var _ddof = (decimal) ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<decimal>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
+                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
 
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    decimal sum = 0;
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
+                            } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<decimal>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
+                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
 
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
+                                    decimal sum = 0;
+                                    while (hasNext()) {
                                         var a = moveNext() - xmean;
                                         sum += a * a;
                                     }
 
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / slice.size)), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
                             }
+                            break;
                         }
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    default:
+				    throw new NotSupportedException();
 
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / (slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(Math.Sqrt(sum / slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-
-                                break;
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Decimal:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(DecimalEx.Sqrt(sum / ((decimal)slice.size - _ddof))), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            else
-                            {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext())
-                                    {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(DecimalEx.Sqrt(sum / (decimal)slice.size)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-
-                            break;
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                default:
-                    throw new NotSupportedException();
-            }
-
-            #endregion
-
-#endif
-
-            if (keepdims)
-                ret.Storage.ExpandDimension(axis);
-
-            return ret;
-        }
-
-        public T StdElementwise<T>(NDArray arr, NPTypeCode? typeCode, int? ddof) where T : unmanaged
-        {
-            return Converts.ChangeType<T>(std_elementwise(arr, typeCode, ddof));
-        }
-
-        protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
-        {
-            if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
-                return NDArray.Scalar(0);
-
-            var retType = typeCode ?? (arr.GetTypeCode).GetComputingType();
-#if _REGEN
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    %foreach except(supported_numericals, "Decimal"), except(supported_numericals_lowercase, "decimal")%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
-			            case NPTypeCode.#101: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<#2>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (#102) Math.Sqrt(sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<#2>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (#102) Math.Sqrt(sum / arr.size);
-                            }
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    %
-                %foreach ["Decimal"], ["decimal"]%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
-			            case NPTypeCode.#101: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<#2>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
-
-                                decimal sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-                                return (#102) DecimalEx.Sqrt(sum / ((decimal) arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<#2>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
-
-                                decimal sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-                                return (#102) DecimalEx.Sqrt(sum / (decimal) arr.size);
-                            }
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    %
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#else
-
-            #region Compute
-
-            switch (arr.GetTypeCode)
-            {
-                case NPTypeCode.Byte:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt16:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt32:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.UInt64:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Char:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Double:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Single:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float)Math.Sqrt(sum / arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Decimal:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
+		    }
+            #endregion
+#endif
 
-                                double sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
+            if (keepdims)
+                ret.Storage.ExpandDimension(axis);
 
-                                return (decimal)Math.Sqrt(sum / arr.size);
-                            }
-                        }
+            return ret;
+        }
 
-                        default:
-                            throw new NotSupportedException();
-                    }
+        public T StdElementwise<T>(NDArray arr, NPTypeCode? typeCode, int? ddof) where T : unmanaged
+        {
+            return Converts.ChangeType<T>(std_elementwise(arr, typeCode, ddof));
+        }
 
-                    break;
-                }
+        protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
+        {
+            if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
+                return NDArray.Scalar(0);
 
-                case NPTypeCode.Double:
+            var retType = typeCode ?? (arr.GetTypeCode).GetComputingType();
+#if _REGEN1
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    %foreach except(supported_numericals, "Decimal"), except(supported_numericals_lowercase, "decimal")%
+			    case NPTypeCode.#1: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+		            {
+			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
+			            case NPTypeCode.#101: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<#2>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (byte)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (#102) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<#2>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (byte)Math.Sqrt(sum / arr.size);
+                                return (#102) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Int16:
+			            %
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    %
+                %foreach ["Decimal"], ["decimal"]%
+			    case NPTypeCode.#1: 
+                {
+                    switch (retType)
+		            {
+			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
+			            case NPTypeCode.#101: 
                         {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                            if (ddof.HasValue) {
+                                var _ddof = (decimal)ddof.Value;
+                                var iter = arr.AsIterator<#2>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
-                                double sum = 0;
-                                while (hasNext())
-                                {
+                                decimal sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (short)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (#102) DecimalEx.Sqrt(sum / ((decimal) arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<#2>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
-                                double sum = 0;
-                                while (hasNext())
-                                {
+                                decimal sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (short)Math.Sqrt(sum / arr.size);
+                                return (#102) DecimalEx.Sqrt(sum / (decimal) arr.size);
                             }
                         }
+			            %
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    %
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#else
 
-                        case NPTypeCode.UInt16:
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    case NPTypeCode.Byte: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (ushort)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (byte) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (ushort)Math.Sqrt(sum / arr.size);
+                                return (byte) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (int)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (int) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (int)Math.Sqrt(sum / arr.size);
+                                return (int) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (uint)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (long) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (uint)Math.Sqrt(sum / arr.size);
+                                return (long) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (long)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (float) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (long)Math.Sqrt(sum / arr.size);
+                                return (float) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.UInt64:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (ulong)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (double) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (ulong)Math.Sqrt(sum / arr.size);
+                                return (double) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Char:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int32: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (char)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (byte) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (char)Math.Sqrt(sum / arr.size);
+                                return (byte) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (double)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (int) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (double)Math.Sqrt(sum / arr.size);
+                                return (int) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (float)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (long) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (float)Math.Sqrt(sum / arr.size);
+                                return (long) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (decimal)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<double>();
+                                return (float) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (decimal)Math.Sqrt(sum / arr.size);
+                                return (float) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    switch (retType)
-                    {
-                        case NPTypeCode.Byte:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (byte)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<float>();
+                                return (double) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (byte)Math.Sqrt(sum / arr.size);
+                                return (double) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Int16:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int64: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (short)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<float>();
+                                return (byte) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (short)Math.Sqrt(sum / arr.size);
+                                return (byte) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (ushort)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<float>();
+                                return (int) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (ushort)Math.Sqrt(sum / arr.size);
+                                return (int) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (int)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<float>();
+                                return (long) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (int)Math.Sqrt(sum / arr.size);
+                                return (long) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (uint)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<float>();
+                                return (float) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (uint)Math.Sqrt(sum / arr.size);
+                                return (float) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (long)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<float>();
+                                return (double) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (long)Math.Sqrt(sum / arr.size);
+                                return (double) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
@@ -10333,36 +2088,30 @@ protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (ulong)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
+                                return (byte) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (ulong)Math.Sqrt(sum / arr.size);
+                                return (byte) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
@@ -10370,36 +2119,30 @@ protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (char)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
+                                return (int) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (char)Math.Sqrt(sum / arr.size);
+                                return (int) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
@@ -10407,36 +2150,30 @@ protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (double)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
+                                return (long) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (double)Math.Sqrt(sum / arr.size);
+                                return (long) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
@@ -10444,36 +2181,30 @@ protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (float)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
+                                return (float) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (float)Math.Sqrt(sum / arr.size);
+                                return (float) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
@@ -10481,269 +2212,203 @@ protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (decimal)Math.Sqrt(sum / (arr.size - _ddof));
-                            }
-                            else
-                            {
+                                return (double) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
                                 double sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (decimal)Math.Sqrt(sum / arr.size);
+                                return (double) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                case NPTypeCode.Decimal:
+			    case NPTypeCode.Double: 
                 {
                     switch (retType)
-                    {
-                        case NPTypeCode.Byte:
-                        {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
-
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
-
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte)DecimalEx.Sqrt(sum / (decimal)arr.size);
-                            }
-                        }
-
-                        case NPTypeCode.Int16:
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
+                            if (ddof.HasValue) {
+                                var _ddof = ddof.Value;
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
+                                double sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (short)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<decimal>();
+                                return (byte) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
+                                double sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (short)DecimalEx.Sqrt(sum / (decimal)arr.size);
+                                return (byte) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.UInt16:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
+                            if (ddof.HasValue) {
+                                var _ddof = ddof.Value;
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
+                                double sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (ushort)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<decimal>();
+                                return (int) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
+                                double sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (ushort)DecimalEx.Sqrt(sum / (decimal)arr.size);
+                                return (int) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Int32:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
+                            if (ddof.HasValue) {
+                                var _ddof = ddof.Value;
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
+                                double sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (int)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<decimal>();
+                                return (long) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
+                                double sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (int)DecimalEx.Sqrt(sum / (decimal)arr.size);
+                                return (long) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.UInt32:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
+                            if (ddof.HasValue) {
+                                var _ddof = ddof.Value;
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
+                                double sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (uint)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<decimal>();
+                                return (float) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
+                                double sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (uint)DecimalEx.Sqrt(sum / (decimal)arr.size);
+                                return (float) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.Int64:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
+                            if (ddof.HasValue) {
+                                var _ddof = ddof.Value;
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
+                                double sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (long)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
-                                var iter = arr.AsIterator<decimal>();
+                                return (double) Math.Sqrt(sum / (arr.size - _ddof));
+                            } else {
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext())
-                                {
+                                double sum = 0;
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
 
-                                return (long)DecimalEx.Sqrt(sum / (decimal)arr.size);
+                                return (double) Math.Sqrt(sum / arr.size);
                             }
                         }
-
-                        case NPTypeCode.UInt64:
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Decimal: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = (decimal)ddof.Value;
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
@@ -10751,36 +2416,28 @@ protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
                                 decimal sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (ulong)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
+                                return (byte) DecimalEx.Sqrt(sum / ((decimal) arr.size - _ddof));
+                            } else {
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
                                 decimal sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (ulong)DecimalEx.Sqrt(sum / (decimal)arr.size);
+                                return (byte) DecimalEx.Sqrt(sum / (decimal) arr.size);
                             }
                         }
-
-                        case NPTypeCode.Char:
+			            case NPTypeCode.Int32: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = (decimal)ddof.Value;
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
@@ -10788,36 +2445,28 @@ protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
                                 decimal sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (char)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
+                                return (int) DecimalEx.Sqrt(sum / ((decimal) arr.size - _ddof));
+                            } else {
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
                                 decimal sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (char)DecimalEx.Sqrt(sum / (decimal)arr.size);
+                                return (int) DecimalEx.Sqrt(sum / (decimal) arr.size);
                             }
                         }
-
-                        case NPTypeCode.Double:
+			            case NPTypeCode.Int64: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = (decimal)ddof.Value;
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
@@ -10825,36 +2474,28 @@ protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
                                 decimal sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (double)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
+                                return (long) DecimalEx.Sqrt(sum / ((decimal) arr.size - _ddof));
+                            } else {
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
                                 decimal sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (double)DecimalEx.Sqrt(sum / (decimal)arr.size);
+                                return (long) DecimalEx.Sqrt(sum / (decimal) arr.size);
                             }
                         }
-
-                        case NPTypeCode.Single:
+			            case NPTypeCode.Single: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = (decimal)ddof.Value;
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
@@ -10862,36 +2503,28 @@ protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
                                 decimal sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (float)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
+                                return (float) DecimalEx.Sqrt(sum / ((decimal) arr.size - _ddof));
+                            } else {
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
                                 decimal sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (float)DecimalEx.Sqrt(sum / (decimal)arr.size);
+                                return (float) DecimalEx.Sqrt(sum / (decimal) arr.size);
                             }
                         }
-
-                        case NPTypeCode.Decimal:
+			            case NPTypeCode.Double: 
                         {
-                            if (ddof.HasValue)
-                            {
+                            if (ddof.HasValue) {
                                 var _ddof = (decimal)ddof.Value;
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
@@ -10899,45 +2532,34 @@ protected object std_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
                                 decimal sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (decimal)DecimalEx.Sqrt(sum / ((decimal)arr.size - _ddof));
-                            }
-                            else
-                            {
+                                return (double) DecimalEx.Sqrt(sum / ((decimal) arr.size - _ddof));
+                            } else {
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
                                 decimal sum = 0;
-                                while (hasNext())
-                                {
+                                while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (decimal)DecimalEx.Sqrt(sum / (decimal)arr.size);
+                                return (double) DecimalEx.Sqrt(sum / (decimal) arr.size);
                             }
                         }
-
-                        default:
-                            throw new NotSupportedException();
-                    }
-
+			            default:
+				            throw new NotSupportedException();
+		            }
                     break;
                 }
-
-                default:
-                    throw new NotSupportedException();
-            }
-
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
     }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Var.cs b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Var.cs
index 2c10ce09a..0195a4951 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Var.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Reduction/Default.Reduction.Var.cs
@@ -58,7 +58,7 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
 
             //resolve the accumulator type
 
-#if _REGEN
+#if _REGEN1
             #region Compute
             switch (arr.GetTypeCode)
 		    {
@@ -114,59 +114,6 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
 				            throw new NotSupportedException();
 		            }
                     break;
-                }
-			    %
-                %foreach ["Decimal"], ["decimal"]%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
-			            case NPTypeCode.#101: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<#2>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.Set#101(Converts.To#101(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<#2>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.Set#101(Converts.To#101(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
                 }
 			    %
 			    default:
@@ -224,7 +171,7 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                 break;
                             }
                         }
-			            case NPTypeCode.Int16: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
@@ -242,7 +189,7 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
@@ -260,12 +207,12 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
@@ -283,7 +230,7 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
@@ -301,12 +248,12 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Single: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
@@ -324,7 +271,7 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
@@ -342,12 +289,12 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Double: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
@@ -365,7 +312,7 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
@@ -383,19 +330,28 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Int64: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int32: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -406,14 +362,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -424,19 +380,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
+                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.UInt64: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -447,14 +403,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -465,19 +421,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt64(Converts.ToUInt64(sum / slice.size), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -488,14 +444,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetChar(Converts.ToChar(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -506,19 +462,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Double: 
+			            case NPTypeCode.Single: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -529,14 +485,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -547,19 +503,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Single: 
+			            case NPTypeCode.Double: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -570,14 +526,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<int>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -588,19 +544,28 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Decimal: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int64: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -611,14 +576,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<byte>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -629,28 +594,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
+                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int16: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -661,14 +617,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -679,19 +635,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Int16: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -702,14 +658,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -720,19 +676,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Single: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -743,14 +699,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -761,19 +717,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Double: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -784,14 +740,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<long>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -802,19 +758,28 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.UInt32: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -825,14 +790,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -843,19 +808,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
+                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -866,14 +831,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -884,19 +849,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.UInt64: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -907,14 +872,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -925,19 +890,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt64(Converts.ToUInt64(sum / slice.size), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Single: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -948,14 +913,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetChar(Converts.ToChar(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -966,7 +931,7 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
@@ -978,7 +943,7 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -996,7 +961,7 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<float>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1012,14 +977,23 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                 break;
                             }
                         }
-			            case NPTypeCode.Single: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Double: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1030,14 +1004,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1048,19 +1022,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
+                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1071,14 +1045,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<short>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1089,28 +1063,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
+                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt16: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1121,14 +1086,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1139,19 +1104,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
+                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Int16: 
+			            case NPTypeCode.Single: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1162,14 +1127,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1180,19 +1145,19 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
+                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Double: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1203,14 +1168,14 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (slice.size - _ddof)), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             } else {
                                 do
                                 {
                                     var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
+                                    var iter = slice.AsIterator<double>();
                                     var moveNext = iter.MoveNext;
                                     var hasNext = iter.HasNext;
                                     var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
@@ -1221,6874 +1186,55 @@ public override NDArray ReduceVar(NDArray arr, int? axis_, bool keepdims = false
                                         sum += a * a;
                                     }
 
-                                    ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
+                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
                                 } while (iterAxis.Next() != null && iterRet.Next() != null);
                                 break;
                             }
                         }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ushort>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int32: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<int>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt32: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<uint>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int64: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<long>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt64: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<ulong>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Char: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<char>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Double: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<double>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Single: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<float>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<double>(slice, NPTypeCode.Double);
-
-                                    double sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                                break;
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Decimal: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetByte(Converts.ToByte(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            case NPTypeCode.Int16: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt16(Converts.ToInt16(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            case NPTypeCode.UInt16: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt16(Converts.ToUInt16(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            case NPTypeCode.Int32: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt32(Converts.ToInt32(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            case NPTypeCode.UInt32: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt32(Converts.ToUInt32(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            case NPTypeCode.Int64: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetInt64(Converts.ToInt64(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            case NPTypeCode.UInt64: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetUInt64(Converts.ToUInt64(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            case NPTypeCode.Char: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetChar(Converts.ToChar(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            case NPTypeCode.Double: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDouble(Converts.ToDouble(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            case NPTypeCode.Single: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetSingle(Converts.ToSingle(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            case NPTypeCode.Decimal: 
-                        {                            
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal) ddof.Value;
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / ((decimal)slice.size - _ddof)), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            } else {
-                                do
-                                {
-                                    var slice = arr[slices];
-                                    var iter = slice.AsIterator<decimal>();
-                                    var moveNext = iter.MoveNext;
-                                    var hasNext = iter.HasNext;
-                                    var xmean = MeanElementwise<decimal>(slice, NPTypeCode.Double);
-
-                                    decimal sum = 0;
-                                    while (hasNext()) {
-                                        var a = moveNext() - xmean;
-                                        sum += a * a;
-                                    }
-
-                                    ret.SetDecimal(Converts.ToDecimal(sum / (decimal)slice.size), iterIndex);
-                                } while (iterAxis.Next() != null && iterRet.Next() != null);
-                            }
-                            break;
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    default:
-				    throw new NotSupportedException();
-
-		    }
-            #endregion
-#endif
-
-            if (keepdims)
-                ret.Storage.ExpandDimension(axis);
-
-            return ret;
-        }
-
-        public T VarElementwise<T>(NDArray arr, NPTypeCode? typeCode, int? ddof) where T : unmanaged
-        {
-            return (T)Converts.ChangeType(var_elementwise(arr, typeCode, ddof), InfoOf<T>.NPTypeCode);
-        }
-
-        protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
-        {
-            if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
-                return NDArray.Scalar(0);
-
-            var retType = typeCode ?? (arr.GetTypeCode).GetComputingType();
-#if _REGEN
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    %foreach except(supported_numericals, "Decimal"), except(supported_numericals_lowercase, "decimal")%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
-			            case NPTypeCode.#101: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<#2>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (#102) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<#2>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (#102) (sum / arr.size);
-                            }
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    %
-                %foreach ["Decimal"], ["decimal"]%
-			    case NPTypeCode.#1: 
-                {
-                    switch (retType)
-		            {
-			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
-			            case NPTypeCode.#101: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<#2>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
-
-                                decimal sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-                                return (#102) (sum / ((decimal) arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<#2>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
-
-                                decimal sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-                                return (#102) (sum / (decimal) arr.size);
-                            }
-                        }
-			            %
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    %
-			    default:
-				    throw new NotSupportedException();
-		    }
-            #endregion
-#else
-
-            #region Compute
-            switch (arr.GetTypeCode)
-		    {
-			    case NPTypeCode.Byte: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<byte>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / arr.size);
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int16: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<short>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / arr.size);
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt16: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ushort>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / arr.size);
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int32: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<int>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / arr.size);
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt32: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<uint>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / arr.size);
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Int64: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<long>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / arr.size);
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.UInt64: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (double) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Single: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (float) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Decimal: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<ulong>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (decimal) (sum / arr.size);
-                            }
-                        }
-			            default:
-				            throw new NotSupportedException();
-		            }
-                    break;
-                }
-			    case NPTypeCode.Char: 
-                {
-                    switch (retType)
-		            {
-			            case NPTypeCode.Byte: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (byte) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ushort) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (int) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt32: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (uint) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (long) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt64: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (ulong) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Char: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (char) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    default:
+				    throw new NotSupportedException();
 
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
+		    }
+            #endregion
+#endif
 
-                                return (char) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Double: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
+            if (keepdims)
+                ret.Storage.ExpandDimension(axis);
 
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
+            return ret;
+        }
 
-                                return (double) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<char>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
+        public T VarElementwise<T>(NDArray arr, NPTypeCode? typeCode, int? ddof) where T : unmanaged
+        {
+            return (T)Converts.ChangeType(var_elementwise(arr, typeCode, ddof), InfoOf<T>.NPTypeCode);
+        }
 
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
+        protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
+        {
+            if (arr.Shape.IsScalar || (arr.Shape.size == 1 && arr.Shape.NDim == 1))
+                return NDArray.Scalar(0);
 
-                                return (double) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.Single: 
+            var retType = typeCode ?? (arr.GetTypeCode).GetComputingType();
+#if _REGEN1
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    %foreach except(supported_numericals, "Decimal"), except(supported_numericals_lowercase, "decimal")%
+			    case NPTypeCode.#1: 
+                {
+                    switch (retType)
+		            {
+			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
+			            case NPTypeCode.#101: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
+                                var iter = arr.AsIterator<#2>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8099,9 +1245,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (float) (sum / (arr.size - _ddof));
+                                return (#102) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<char>();
+                                var iter = arr.AsIterator<#2>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8112,46 +1258,68 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (float) (sum / arr.size);
+                                return (#102) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Decimal: 
+			            %
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    %
+                %foreach ["Decimal"], ["decimal"]%
+			    case NPTypeCode.#1: 
+                {
+                    switch (retType)
+		            {
+			            %foreach supported_numericals,supported_numericals_lowercase,supported_numericals_onevales%
+			            case NPTypeCode.#101: 
                         {
                             if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<char>();
+                                var _ddof = (decimal)ddof.Value;
+                                var iter = arr.AsIterator<#2>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
-                                double sum = 0;
+                                decimal sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (decimal) (sum / (arr.size - _ddof));
+                                return (#102) (sum / ((decimal) arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<char>();
+                                var iter = arr.AsIterator<#2>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
-                                double sum = 0;
+                                decimal sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-
-                                return (decimal) (sum / arr.size);
+                                return (#102) (sum / (decimal) arr.size);
                             }
                         }
+			            %
 			            default:
 				            throw new NotSupportedException();
 		            }
                     break;
                 }
-			    case NPTypeCode.Double: 
+			    %
+			    default:
+				    throw new NotSupportedException();
+		    }
+            #endregion
+#else
+
+            #region Compute
+            switch (arr.GetTypeCode)
+		    {
+			    case NPTypeCode.Byte: 
                 {
                     switch (retType)
 		            {
@@ -8159,7 +1327,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8172,7 +1340,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
 
                                 return (byte) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8186,42 +1354,11 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 return (byte) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<double>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8232,9 +1369,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (ushort) (sum / (arr.size - _ddof));
+                                return (int) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8245,14 +1382,14 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (ushort) (sum / arr.size);
+                                return (int) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8263,9 +1400,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (int) (sum / (arr.size - _ddof));
+                                return (long) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8276,14 +1413,14 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (int) (sum / arr.size);
+                                return (long) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Single: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8294,9 +1431,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (uint) (sum / (arr.size - _ddof));
+                                return (float) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8307,14 +1444,14 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (uint) (sum / arr.size);
+                                return (float) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Double: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8325,9 +1462,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (long) (sum / (arr.size - _ddof));
+                                return (double) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<byte>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8338,14 +1475,23 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (long) (sum / arr.size);
+                                return (double) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.UInt64: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Int32: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8356,9 +1502,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (ulong) (sum / (arr.size - _ddof));
+                                return (byte) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8369,14 +1515,14 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (ulong) (sum / arr.size);
+                                return (byte) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8387,9 +1533,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (char) (sum / (arr.size - _ddof));
+                                return (int) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8400,14 +1546,14 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (char) (sum / arr.size);
+                                return (int) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Double: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8418,9 +1564,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (double) (sum / (arr.size - _ddof));
+                                return (long) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8431,14 +1577,14 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (double) (sum / arr.size);
+                                return (long) (sum / arr.size);
                             }
                         }
 			            case NPTypeCode.Single: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8451,7 +1597,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
 
                                 return (float) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8465,11 +1611,11 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 return (float) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8480,9 +1626,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (decimal) (sum / (arr.size - _ddof));
+                                return (double) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<double>();
+                                var iter = arr.AsIterator<int>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8493,7 +1639,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (decimal) (sum / arr.size);
+                                return (double) (sum / arr.size);
                             }
                         }
 			            default:
@@ -8501,7 +1647,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
 		            }
                     break;
                 }
-			    case NPTypeCode.Single: 
+			    case NPTypeCode.Int64: 
                 {
                     switch (retType)
 		            {
@@ -8509,7 +1655,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8522,7 +1668,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
 
                                 return (byte) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8536,42 +1682,11 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 return (byte) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / (arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<float>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
-
-                                double sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-
-                                return (short) (sum / arr.size);
-                            }
-                        }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8582,9 +1697,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (ushort) (sum / (arr.size - _ddof));
+                                return (int) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8595,14 +1710,14 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (ushort) (sum / arr.size);
+                                return (int) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8613,9 +1728,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (int) (sum / (arr.size - _ddof));
+                                return (long) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8626,14 +1741,14 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (int) (sum / arr.size);
+                                return (long) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Single: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8644,9 +1759,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (uint) (sum / (arr.size - _ddof));
+                                return (float) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8657,14 +1772,14 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (uint) (sum / arr.size);
+                                return (float) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Double: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8675,9 +1790,9 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (long) (sum / (arr.size - _ddof));
+                                return (double) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<float>();
+                                var iter = arr.AsIterator<long>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
                                 var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
@@ -8688,10 +1803,19 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (long) (sum / arr.size);
+                                return (double) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.UInt64: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Single: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
@@ -8706,7 +1830,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (ulong) (sum / (arr.size - _ddof));
+                                return (byte) (sum / (arr.size - _ddof));
                             } else {
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
@@ -8719,10 +1843,10 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (ulong) (sum / arr.size);
+                                return (byte) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
@@ -8737,7 +1861,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (char) (sum / (arr.size - _ddof));
+                                return (int) (sum / (arr.size - _ddof));
                             } else {
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
@@ -8750,10 +1874,10 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (char) (sum / arr.size);
+                                return (int) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Double: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
@@ -8768,7 +1892,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (double) (sum / (arr.size - _ddof));
+                                return (long) (sum / (arr.size - _ddof));
                             } else {
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
@@ -8781,7 +1905,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (double) (sum / arr.size);
+                                return (long) (sum / arr.size);
                             }
                         }
 			            case NPTypeCode.Single: 
@@ -8815,7 +1939,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 return (float) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = ddof.Value;
@@ -8830,7 +1954,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (decimal) (sum / (arr.size - _ddof));
+                                return (double) (sum / (arr.size - _ddof));
                             } else {
                                 var iter = arr.AsIterator<float>();
                                 var moveNext = iter.MoveNext;
@@ -8843,7 +1967,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     sum += a * a;
                                 }
 
-                                return (decimal) (sum / arr.size);
+                                return (double) (sum / arr.size);
                             }
                         }
 			            default:
@@ -8851,185 +1975,175 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
 		            }
                     break;
                 }
-			    case NPTypeCode.Decimal: 
+			    case NPTypeCode.Double: 
                 {
                     switch (retType)
 		            {
 			            case NPTypeCode.Byte: 
                         {
                             if (ddof.HasValue) {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
-
-                                decimal sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-                                return (byte) (sum / ((decimal) arr.size - _ddof));
-                            } else {
-                                var iter = arr.AsIterator<decimal>();
+                                var _ddof = ddof.Value;
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
+                                double sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (byte) (sum / (decimal) arr.size);
-                            }
-                        }
-			            case NPTypeCode.Int16: 
-                        {
-                            if (ddof.HasValue) {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
-                                var moveNext = iter.MoveNext;
-                                var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
-                                while (hasNext()) {
-                                    var a = moveNext() - xmean;
-                                    sum += a * a;
-                                }
-                                return (short) (sum / ((decimal) arr.size - _ddof));
+                                return (byte) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<decimal>();
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
+                                double sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (short) (sum / (decimal) arr.size);
+
+                                return (byte) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.UInt16: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
+                                var _ddof = ddof.Value;
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
+                                double sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (ushort) (sum / ((decimal) arr.size - _ddof));
+
+                                return (int) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<decimal>();
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
+                                double sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (ushort) (sum / (decimal) arr.size);
+
+                                return (int) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Int32: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
+                                var _ddof = ddof.Value;
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
+                                double sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (int) (sum / ((decimal) arr.size - _ddof));
+
+                                return (long) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<decimal>();
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
+                                double sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (int) (sum / (decimal) arr.size);
+
+                                return (long) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.UInt32: 
+			            case NPTypeCode.Single: 
                         {
                             if (ddof.HasValue) {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
+                                var _ddof = ddof.Value;
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
+                                double sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (uint) (sum / ((decimal) arr.size - _ddof));
+
+                                return (float) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<decimal>();
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
+                                double sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (uint) (sum / (decimal) arr.size);
+
+                                return (float) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.Int64: 
+			            case NPTypeCode.Double: 
                         {
                             if (ddof.HasValue) {
-                                var _ddof = (decimal)ddof.Value;
-                                var iter = arr.AsIterator<decimal>();
+                                var _ddof = ddof.Value;
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
+                                double sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (long) (sum / ((decimal) arr.size - _ddof));
+
+                                return (double) (sum / (arr.size - _ddof));
                             } else {
-                                var iter = arr.AsIterator<decimal>();
+                                var iter = arr.AsIterator<double>();
                                 var moveNext = iter.MoveNext;
                                 var hasNext = iter.HasNext;
-                                var xmean = MeanElementwise<decimal>(arr, NPTypeCode.Double);
+                                var xmean = MeanElementwise<double>(arr, NPTypeCode.Double);
 
-                                decimal sum = 0;
+                                double sum = 0;
                                 while (hasNext()) {
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (long) (sum / (decimal) arr.size);
+
+                                return (double) (sum / arr.size);
                             }
                         }
-			            case NPTypeCode.UInt64: 
+			            default:
+				            throw new NotSupportedException();
+		            }
+                    break;
+                }
+			    case NPTypeCode.Decimal: 
+                {
+                    switch (retType)
+		            {
+			            case NPTypeCode.Byte: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = (decimal)ddof.Value;
@@ -9043,7 +2157,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (ulong) (sum / ((decimal) arr.size - _ddof));
+                                return (byte) (sum / ((decimal) arr.size - _ddof));
                             } else {
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
@@ -9055,10 +2169,10 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (ulong) (sum / (decimal) arr.size);
+                                return (byte) (sum / (decimal) arr.size);
                             }
                         }
-			            case NPTypeCode.Char: 
+			            case NPTypeCode.Int32: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = (decimal)ddof.Value;
@@ -9072,7 +2186,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (char) (sum / ((decimal) arr.size - _ddof));
+                                return (int) (sum / ((decimal) arr.size - _ddof));
                             } else {
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
@@ -9084,10 +2198,10 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (char) (sum / (decimal) arr.size);
+                                return (int) (sum / (decimal) arr.size);
                             }
                         }
-			            case NPTypeCode.Double: 
+			            case NPTypeCode.Int64: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = (decimal)ddof.Value;
@@ -9101,7 +2215,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (double) (sum / ((decimal) arr.size - _ddof));
+                                return (long) (sum / ((decimal) arr.size - _ddof));
                             } else {
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
@@ -9113,7 +2227,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (double) (sum / (decimal) arr.size);
+                                return (long) (sum / (decimal) arr.size);
                             }
                         }
 			            case NPTypeCode.Single: 
@@ -9145,7 +2259,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                 return (float) (sum / (decimal) arr.size);
                             }
                         }
-			            case NPTypeCode.Decimal: 
+			            case NPTypeCode.Double: 
                         {
                             if (ddof.HasValue) {
                                 var _ddof = (decimal)ddof.Value;
@@ -9159,7 +2273,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (decimal) (sum / ((decimal) arr.size - _ddof));
+                                return (double) (sum / ((decimal) arr.size - _ddof));
                             } else {
                                 var iter = arr.AsIterator<decimal>();
                                 var moveNext = iter.MoveNext;
@@ -9171,7 +2285,7 @@ protected object var_elementwise(NDArray arr, NPTypeCode? typeCode, int? ddof)
                                     var a = moveNext() - xmean;
                                     sum += a * a;
                                 }
-                                return (decimal) (sum / (decimal) arr.size);
+                                return (double) (sum / (decimal) arr.size);
                             }
                         }
 			            default:
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Boolean.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Boolean.cs
index c2b66e60b..42b3717a4 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Boolean.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Boolean.cs
@@ -28,7 +28,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of bool
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Subtract"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,6126 +238,24 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt16(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt16(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt16(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt16(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt16(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt16(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt16(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt16(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt32(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt32(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt32(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt32(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt32(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt64(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToInt64(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToUInt64(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToUInt64(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToUInt64(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToChar(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToChar(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToChar(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToChar(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToChar(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDouble(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToDouble(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToSingle(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToSingle(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDecimal(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDecimal(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToDecimal(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt32(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6365,13 +263,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt32(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6379,7 +277,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToInt32(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6389,30 +287,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToInt32(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToInt64(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6420,13 +318,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToInt64(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6434,7 +332,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToInt64(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6444,30 +342,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToInt64(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToSingle(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6475,13 +373,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToSingle(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6489,7 +387,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToSingle(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6499,30 +397,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToSingle(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToDouble(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6530,13 +428,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToDouble(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6544,7 +442,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToDouble(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6554,30 +452,48 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToDouble(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6585,13 +501,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6599,7 +515,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6609,30 +525,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6640,13 +556,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6654,7 +570,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6664,30 +580,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6695,13 +611,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6709,7 +625,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6719,30 +635,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6750,13 +666,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6764,7 +680,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6774,7 +690,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -6835,24 +751,24 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -6860,13 +776,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -6874,7 +790,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -6884,7 +800,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -6894,15 +810,15 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Single: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((float*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7018,24 +934,24 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7043,13 +959,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7057,7 +973,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7067,30 +983,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7098,13 +1014,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7112,7 +1028,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7122,30 +1038,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((bool*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray SubtractBoolean(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Byte.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Byte.cs
index b69702372..d799bb4ed 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Byte.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Byte.cs
@@ -28,7 +28,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of byte
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Subtract"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((byte*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (byte*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray SubtractByte(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Char.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Char.cs
deleted file mode 100644
index 6b0e2b799..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Char.cs
+++ /dev/null
@@ -1,8259 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray SubtractChar(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of char
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Subtract"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((char*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("char"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((char*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Decimal.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Decimal.cs
deleted file mode 100644
index e7d84899d..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Decimal.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray SubtractDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray SubtractDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of decimal
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Subtract"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((decimal*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("decimal"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((decimal*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Double.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Double.cs
index d84156d65..1646568b4 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Double.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Double.cs
@@ -28,7 +28,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of double
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Subtract"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((double*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (double*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray SubtractDouble(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int16.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int16.cs
deleted file mode 100644
index b1e51897c..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int16.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray SubtractInt16(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray SubtractInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of short
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Subtract"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((short*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("short"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((short*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int32.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int32.cs
index 9961c25f3..6e3037cfe 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int32.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int32.cs
@@ -28,7 +28,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of int
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Subtract"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((int*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (int*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray SubtractInt32(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int64.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int64.cs
index 0097465bc..e5d63d2f2 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int64.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Int64.cs
@@ -34,7 +34,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of long
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Subtract"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -244,24 +244,24 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -269,13 +269,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -283,7 +283,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -293,30 +293,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -324,13 +324,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -338,7 +338,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -348,30 +348,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -379,13 +379,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -393,7 +393,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -403,30 +403,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -434,13 +434,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -448,7 +448,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -458,30 +458,48 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -489,13 +507,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -503,7 +521,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -513,30 +531,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -544,13 +562,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -558,7 +576,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -568,30 +586,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -599,13 +617,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -613,7 +631,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -623,30 +641,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -654,13 +672,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -668,7 +686,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -678,7 +696,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -739,24 +757,24 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -764,13 +782,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -778,7 +796,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -788,7 +806,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -798,15 +816,15 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -920,116 +938,6 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1087,24 +995,24 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1112,13 +1020,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1126,7 +1034,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1136,6022 +1044,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7159,13 +1075,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7173,7 +1089,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7183,30 +1099,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7214,13 +1130,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7228,7 +1144,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7238,30 +1154,48 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7269,13 +1203,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7283,7 +1217,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7293,30 +1227,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7324,13 +1258,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7338,7 +1272,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7348,30 +1282,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7379,13 +1313,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7393,7 +1327,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7403,30 +1337,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7434,13 +1368,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7448,7 +1382,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7458,7 +1392,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7519,24 +1453,24 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7544,13 +1478,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7558,7 +1492,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7568,7 +1502,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7578,15 +1512,15 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7702,24 +1636,24 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7727,13 +1661,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7741,7 +1675,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7751,30 +1685,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7782,13 +1716,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7796,7 +1730,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7806,30 +1740,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7837,13 +1771,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7851,7 +1785,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7861,30 +1795,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7892,13 +1826,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7906,7 +1840,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7916,30 +1850,48 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((long*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (long*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7947,13 +1899,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7961,7 +1913,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7971,30 +1923,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8002,13 +1954,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8016,7 +1968,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8026,30 +1978,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8057,13 +2009,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8071,7 +2023,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8081,30 +2033,30 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8112,13 +2064,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8126,7 +2078,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8136,7 +2088,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8197,24 +2149,24 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8222,13 +2174,13 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8236,7 +2188,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8246,7 +2198,7 @@ public unsafe NDArray SubtractInt64(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Single.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Single.cs
index 90a8741c1..b5cf071dc 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Single.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.Single.cs
@@ -28,7 +28,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of float
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "Subtract"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -238,24 +238,24 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -263,13 +263,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -277,7 +277,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -287,30 +287,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -318,13 +318,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -332,7 +332,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -342,30 +342,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -373,13 +373,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -387,7 +387,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -397,30 +397,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -428,13 +428,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -442,7 +442,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -452,30 +452,48 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -483,13 +501,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -497,7 +515,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -507,30 +525,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -538,13 +556,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -552,7 +570,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -562,30 +580,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -593,13 +611,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -607,7 +625,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -617,30 +635,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -648,13 +666,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -662,7 +680,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -672,7 +690,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -733,24 +751,24 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -758,13 +776,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -772,7 +790,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -782,7 +800,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -792,15 +810,15 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Byte: {
+                case NPTypeCode.Int32: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((int*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
+                    var rhs_address = (int*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -914,116 +932,6 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 } while (incr.Next() != null);
                             }
 
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
                             return ret;
 	                    }
 	                    case NPTypeCode.Int32: {
@@ -1081,24 +989,24 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -1106,13 +1014,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -1120,7 +1028,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -1130,6022 +1038,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
 	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7153,13 +1069,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7167,7 +1083,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7177,30 +1093,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7208,13 +1124,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7222,7 +1138,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7232,30 +1148,48 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7263,13 +1197,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7277,7 +1211,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7287,30 +1221,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7318,13 +1252,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7332,7 +1266,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7342,30 +1276,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7373,13 +1307,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7387,7 +1321,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7397,30 +1331,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7428,13 +1362,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7442,7 +1376,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7452,7 +1386,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7513,24 +1447,24 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7538,13 +1472,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7552,7 +1486,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7562,7 +1496,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -7572,15 +1506,15 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
 		                    throw new NotSupportedException();
                     }
                 }
-                case NPTypeCode.Decimal: {
+                case NPTypeCode.Single: {
                     //if return type is scalar
                     var ret_type = np._FindCommonType(lhs, rhs);
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((float*)rhs.Address)), ret_type));
                     
                     (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (float*)rhs.Address;
                     var retShape = leftshape.Clean();
                     var ret = new NDArray(ret_type, retShape, false);
                     var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
@@ -7696,24 +1630,24 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7721,13 +1655,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7735,7 +1669,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7745,30 +1679,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7776,13 +1710,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7790,7 +1724,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7800,30 +1734,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7831,13 +1765,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7845,7 +1779,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7855,30 +1789,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7886,13 +1820,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7900,7 +1834,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7910,30 +1844,48 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((float*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (float*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7941,13 +1893,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -7955,7 +1907,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -7965,30 +1917,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -7996,13 +1948,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8010,7 +1962,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8020,30 +1972,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8051,13 +2003,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8065,7 +2017,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8075,30 +2027,30 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8106,13 +2058,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8120,7 +2072,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8130,7 +2082,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
@@ -8191,24 +2143,24 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
 
                             return ret;
 	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
                             if (leftLinear && rightLinear) {
                                 var len = ret.size;
                                 Debug.Assert(leftshape.size == len && rightshape.size == len);
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
                                 }
                             } else if (leftLinear) { // && !rightLinear
                                 if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
                                 } else {
                                     int leftOffset = 0;
                                     int retOffset = 0;
@@ -8216,13 +2168,13 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> rightOffset = rightshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
                                     } while (incr.Next() != null);
                                 }
                             } else if (rightLinear) { // !leftLinear && 
                                 if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
                                     var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
                                 } else {
                                     int rightOffset = 0;
                                     int retOffset = 0;
@@ -8230,7 +2182,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                     int[] current = incr.Index;
                                     Func<int[], int> leftOffset = leftshape.GetOffset;
                                     do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
                                     } while (incr.Next() != null);
                                 }
                             } else {
@@ -8240,7 +2192,7 @@ public unsafe NDArray SubtractSingle(in NDArray lhs, in NDArray rhs)
                                 Func<int[], int> rightOffset = rightshape.GetOffset;
                                 Func<int[], int> leftOffset = leftshape.GetOffset;
                                 do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
                                 } while (incr.Next() != null);
                             }
 
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.UInt16.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.UInt16.cs
deleted file mode 100644
index 220a2bb2d..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.UInt16.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray SubtractUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray SubtractUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ushort
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Subtract"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((ushort*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("ushort"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ushort*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.UInt32.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.UInt32.cs
deleted file mode 100644
index ac55227bf..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.UInt32.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray SubtractUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray SubtractUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of uint
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Subtract"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((uint*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("uint"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((uint*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.UInt64.cs b/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.UInt64.cs
deleted file mode 100644
index 4644e1e4d..000000000
--- a/src/NumSharp.Core/Backends/Default/Math/Subtract/Default.Subtract.UInt64.cs
+++ /dev/null
@@ -1,8266 +0,0 @@
-//Generated by Regex Templating Engine at 11/08/2019 19:26:50 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Backends\Default\Math\Templates\Default.Op.General.template.cs
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-using NumSharp.Backends.Unmanaged;
-using NumSharp.Utilities;
-using NumSharp.Utilities.Maths;
-
-namespace NumSharp.Backends
-{
-    //v2
-    public partial class DefaultEngine
-    {
-#if MINIMAL
-        public unsafe NDArray SubtractUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            return null;
-        }
-#else
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray SubtractUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ulong
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "Subtract"
-                %op_bool = "*"
-	            %foreach supported_dtypes, supported_dtypes_lowercase%
-                case NPTypeCode.#1: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.#(op)(*((ulong*)lhs.Address), *((#2*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-                        %foreach supported_dtypes,supported_dtypes_lowercase%
-                        |#normalcast = ("("+str("#102")+")")
-                        |#caster = ( "#102"=="bool" | ("Converts.To" + str("#101")) | ("ulong"=="bool"|("#2"=="bool"|("Converts.To" + str("#101"))|normalcast)| normalcast) )
-	                    case NPTypeCode.#101: {
-		                    var ret_address = (#102*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = #(caster)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = #(caster)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-                        %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((bool*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Byte: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((byte*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((short*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt16: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((ushort*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((int*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt32: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((uint*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Int64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((long*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.UInt64: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((ulong*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Char: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((char*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Double: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((double*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Single: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((float*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                case NPTypeCode.Decimal: {
-                    //if return type is scalar
-                    var ret_type = np._FindCommonType(lhs, rhs);
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar(Converts.ChangeType(Operator.Subtract(*((ulong*)lhs.Address), *((decimal*)rhs.Address)), ret_type));
-                    
-                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var retShape = leftshape.Clean();
-                    var ret = new NDArray(ret_type, retShape, false);
-                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
-                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
-                    switch (ret_type) {
-	                    case NPTypeCode.Boolean: {
-		                    var ret_address = (bool*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Byte: {
-		                    var ret_address = (byte*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (byte)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int16: {
-		                    var ret_address = (short*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (short)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (short)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt16: {
-		                    var ret_address = (ushort*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ushort)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ushort)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int32: {
-		                    var ret_address = (int*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (int)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt32: {
-		                    var ret_address = (uint*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (uint)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (uint)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Int64: {
-		                    var ret_address = (long*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (long)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.UInt64: {
-		                    var ret_address = (ulong*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (ulong)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (ulong)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Char: {
-		                    var ret_address = (char*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (char)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (char)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Double: {
-		                    var ret_address = (double*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (double)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Single: {
-		                    var ret_address = (float*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (float)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    case NPTypeCode.Decimal: {
-		                    var ret_address = (decimal*)ret.Address;
-                            if (leftLinear && rightLinear) {
-                                var len = ret.size;
-                                Debug.Assert(leftshape.size == len && rightshape.size == len);
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    Parallel.For(0, len, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), (*(rhs_address + i)))));
-                                }
-                            } else if (leftLinear) { // && !rightLinear
-                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var rval =  *rhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract((*(lhs_address + i)), rval)));
-                                } else {
-                                    int leftOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> rightOffset = rightshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else if (rightLinear) { // !leftLinear && 
-                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
-                                    var lval =  *lhs_address;
-                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (decimal)(Operator.Subtract(lval, (*(rhs_address + i)))));
-                                } else {
-                                    int rightOffset = 0;
-                                    int retOffset = 0;
-                                    var incr = new NDCoordinatesIncrementor(ref retShape);
-                                    int[] current = incr.Index;
-                                    Func<int[], int> leftOffset = leftshape.GetOffset;
-                                    do {
-                                        *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
-                                    } while (incr.Next() != null);
-                                }
-                            } else {
-                                int retOffset = 0;
-                                var incr = new NDCoordinatesIncrementor(ref retShape);
-                                int[] current = incr.Index;
-                                Func<int[], int> rightOffset = rightshape.GetOffset;
-                                Func<int[], int> leftOffset = leftshape.GetOffset;
-                                do {
-                                    *(ret_address + retOffset++) = (decimal)(Operator.Subtract((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
-                                } while (incr.Next() != null);
-                            }
-
-                            return ret;
-	                    }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-                }
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-#endif
-    }
-}
diff --git a/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.Dot.Boolean.template.cs b/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.Dot.Boolean.template.cs
index 3a38e1df7..d794823ee 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.Dot.Boolean.template.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.Dot.Boolean.template.cs
@@ -28,7 +28,7 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of bool
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "*"
                 %op_bool = "&"
                 case NPTypeCode.Boolean:
@@ -373,6 +373,1016 @@ public unsafe NDArray MultiplyBoolean(in NDArray lhs, in NDArray rhs)
 		            throw new NotSupportedException();
 #else
 
+                case NPTypeCode.Boolean:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType((*((bool*)lhs.Address)) & (*((bool*)rhs.Address)), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (bool*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToBoolean((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) & (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                case NPTypeCode.Byte:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((bool*)lhs.Address) ? (byte) 1 : (byte) 0 * *((byte*)rhs.Address), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current))) != 0;
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (byte) 1 : (byte) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                case NPTypeCode.Int32:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((bool*)lhs.Address) ? (int) 1 : (int) 0 * *((int*)rhs.Address), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (int*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current))) != 0;
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (int) 1 : (int) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                case NPTypeCode.Int64:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((bool*)lhs.Address) ? (long) 1 : (long) 0 * *((long*)rhs.Address), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current))) != 0;
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (long) 1 : (long) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                case NPTypeCode.Single:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((bool*)lhs.Address) ? (float) 1 : (float) 0 * *((float*)rhs.Address), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (float*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current))) != 0;
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (float) 1 : (float) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                case NPTypeCode.Double:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((bool*)lhs.Address) ? (double) 1 : (double) 0 * *((double*)rhs.Address), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (bool*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current))) != 0;
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? (double) 1 : (double) 0) * *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                default:
+		            throw new NotSupportedException();
 #endif
             }
         }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.Dot.template.cs b/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.Dot.template.cs
index d44e73b59..f976c46e2 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.Dot.template.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.Dot.template.cs
@@ -27,7 +27,7 @@ public unsafe NDArray Dot__1__(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of __2__
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "*"
                 %op_bool = "*"
                 case NPTypeCode.Boolean:
@@ -372,6 +372,1016 @@ public unsafe NDArray Dot__1__(in NDArray lhs, in NDArray rhs)
 		            throw new NotSupportedException();
 #else
 
+                case NPTypeCode.Boolean:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((__2__*)lhs.Address) * (*((bool*)rhs.Address) ? (__2__) 1 : (__2__) 0), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (bool*)rhs.Address;
+                    var ret = new NDArray(ret_type, BroadcastedLeftShape.Clean(), false);
+                    Shape retShape = ret.Shape;
+                    
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToBoolean((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) != 0 ? 1 : 0) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal(((__2__)*(lhs_address + BroadcastedLeftShape.GetOffset(current))) * (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? (__2__) 1 : (__2__) 0));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                case NPTypeCode.Byte:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((__2__*)lhs.Address) * *((byte*)rhs.Address), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+                    
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = 0 != (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                case NPTypeCode.Int32:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((__2__*)lhs.Address) * *((int*)rhs.Address), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (int*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+                    
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = 0 != (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                case NPTypeCode.Int64:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((__2__*)lhs.Address) * *((long*)rhs.Address), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+                    
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = 0 != (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                case NPTypeCode.Single:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((__2__*)lhs.Address) * *((float*)rhs.Address), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (float*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+                    
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = 0 != (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                case NPTypeCode.Double:
+                {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    {
+                        return NDArray.Scalar(Converts.ChangeType(*((__2__*)lhs.Address) * *((double*)rhs.Address), (TypeCode)ret_type));
+                    }
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var ret = new NDArray(ret_type, new Shape(BroadcastedLeftShape.dimensions), false);
+                    Shape retShape = ret.Shape;
+                    
+                    switch (ret_type)
+                    {
+	                    case NPTypeCode.Boolean:
+	                    {
+		                    var ret_address = (bool*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = 0 != (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte:
+	                    {
+		                    var ret_address = (byte*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToByte(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int16:
+	                    {
+		                    var ret_address = (short*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt16(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt16:
+	                    {
+		                    var ret_address = (ushort*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt16(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32:
+	                    {
+		                    var ret_address = (int*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt32(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt32:
+	                    {
+		                    var ret_address = (uint*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt32(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64:
+	                    {
+		                    var ret_address = (long*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToInt64(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.UInt64:
+	                    {
+		                    var ret_address = (ulong*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToUInt64(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Char:
+	                    {
+		                    var ret_address = (char*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToChar(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double:
+	                    {
+		                    var ret_address = (double*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDouble(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single:
+	                    {
+		                    var ret_address = (float*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToSingle(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Decimal:
+	                    {
+		                    var ret_address = (decimal*)ret.Address;
+                            var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                            int[] current = incr.Index;
+                            do
+                            {
+                                *(ret_address + retShape.GetOffset(current)) = Converts.ToDecimal(*(lhs_address + BroadcastedLeftShape.GetOffset(current)) * (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                            } while (incr.Next() != null);
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+
+                    }
+
+                    break;
+                }
+
+                default:
+		            throw new NotSupportedException();
 #endif
             }
         }
diff --git a/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.General.template.cs b/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.General.template.cs
index 0684f5293..b385969da 100644
--- a/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.General.template.cs
+++ b/src/NumSharp.Core/Backends/Default/Math/Templates/Default.Op.General.template.cs
@@ -33,7 +33,7 @@ public unsafe NDArray __3____1__(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of __2__
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "__3__"
                 %op_bool = "*"
 	            %foreach supported_dtypes, supported_dtypes_lowercase%
@@ -119,6 +119,2096 @@ public unsafe NDArray __3____1__(in NDArray lhs, in NDArray rhs)
 		            throw new NotSupportedException();
 #else
 
+                case NPTypeCode.Boolean: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.__3__(*((__2__*)lhs.Address), *((bool*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (bool*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Byte: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.__3__(*((__2__*)lhs.Address), *((byte*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int32: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.__3__(*((__2__*)lhs.Address), *((int*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (int*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Int64: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.__3__(*((__2__*)lhs.Address), *((long*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Single: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.__3__(*((__2__*)lhs.Address), *((float*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (float*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                case NPTypeCode.Double: {
+                    //if return type is scalar
+                    var ret_type = np._FindCommonType(lhs, rhs);
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar(Converts.ChangeType(Operator.__3__(*((__2__*)lhs.Address), *((double*)rhs.Address)), ret_type));
+                    
+                    (Shape leftshape, Shape rightshape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var retShape = leftshape.Clean();
+                    var ret = new NDArray(ret_type, retShape, false);
+                    var leftLinear = !leftshape.IsBroadcasted && !leftshape.IsSliced;
+                    var rightLinear = !rightshape.IsBroadcasted && !rightshape.IsSliced;
+                    switch (ret_type) {
+	                    case NPTypeCode.Boolean: {
+		                    var ret_address = (bool*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = Converts.ToBoolean(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = Converts.ToBoolean(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Byte: {
+		                    var ret_address = (byte*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (byte)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (byte)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int32: {
+		                    var ret_address = (int*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (int)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (int)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Int64: {
+		                    var ret_address = (long*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (long)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (long)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Single: {
+		                    var ret_address = (float*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (float)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (float)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    case NPTypeCode.Double: {
+		                    var ret_address = (double*)ret.Address;
+                            if (leftLinear && rightLinear) {
+                                var len = ret.size;
+                                Debug.Assert(leftshape.size == len && rightshape.size == len);
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    Parallel.For(0, len, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), (*(rhs_address + i)))));
+                                }
+                            } else if (leftLinear) { // && !rightLinear
+                                if (rightshape.IsBroadcasted && rightshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var rval =  *rhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__((*(lhs_address + i)), rval)));
+                                } else {
+                                    int leftOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> rightOffset = rightshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset++)), (*(rhs_address + rightOffset(current)))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else if (rightLinear) { // !leftLinear && 
+                                if (leftshape.IsBroadcasted && leftshape.BroadcastInfo.OriginalShape.IsScalar) {
+                                    var lval =  *lhs_address;
+                                    Parallel.For(0, ret.size, i => *(ret_address + i) = (double)(Operator.__3__(lval, (*(rhs_address + i)))));
+                                } else {
+                                    int rightOffset = 0;
+                                    int retOffset = 0;
+                                    var incr = new NDCoordinatesIncrementor(ref retShape);
+                                    int[] current = incr.Index;
+                                    Func<int[], int> leftOffset = leftshape.GetOffset;
+                                    do {
+                                        *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset++))));
+                                    } while (incr.Next() != null);
+                                }
+                            } else {
+                                int retOffset = 0;
+                                var incr = new NDCoordinatesIncrementor(ref retShape);
+                                int[] current = incr.Index;
+                                Func<int[], int> rightOffset = rightshape.GetOffset;
+                                Func<int[], int> leftOffset = leftshape.GetOffset;
+                                do {
+                                    *(ret_address + retOffset++) = (double)(Operator.__3__((*(lhs_address + leftOffset(current))), (*(rhs_address + rightOffset(current)))));
+                                } while (incr.Next() != null);
+                            }
+
+                            return ret;
+	                    }
+	                    default:
+		                    throw new NotSupportedException();
+                    }
+                }
+                default:
+		            throw new NotSupportedException();
 #endif
             }
         }
diff --git a/src/NumSharp.Core/Backends/Iterators/MultiIterator.cs b/src/NumSharp.Core/Backends/Iterators/MultiIterator.cs
index a5bfa8523..bd45c4ec4 100644
--- a/src/NumSharp.Core/Backends/Iterators/MultiIterator.cs
+++ b/src/NumSharp.Core/Backends/Iterators/MultiIterator.cs
@@ -21,7 +21,7 @@ public static void Assign(NDArray lhs, NDArray rhs)
         /// <remarks>Stops at first iterator stop.</remarks>
         public static void Assign(UnmanagedStorage lhs, UnmanagedStorage rhs)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (lhs.TypeCode)
 		    {
@@ -40,83 +40,47 @@ public static void Assign(UnmanagedStorage lhs, UnmanagedStorage rhs)
 #else
 
             #region Compute
-            switch (lhs.TypeCode)
-            {
-                case NPTypeCode.Boolean:
-                {
+		    switch (lhs.TypeCode)
+		    {
+			    case NPTypeCode.Boolean:
+			    {
                     var (l, r)= GetIterators<bool>(lhs, rhs, true);
                     AssignBroadcast<bool>(l, r);
                     break;
-                }
-                case NPTypeCode.Byte:
-                {
+			    }
+			    case NPTypeCode.Byte:
+			    {
                     var (l, r)= GetIterators<byte>(lhs, rhs, true);
                     AssignBroadcast<byte>(l, r);
                     break;
-                }
-                case NPTypeCode.Int16:
-                {
-                    var (l, r)= GetIterators<short>(lhs, rhs, true);
-                    AssignBroadcast<short>(l, r);
-                    break;
-                }
-                case NPTypeCode.UInt16:
-                {
-                    var (l, r)= GetIterators<ushort>(lhs, rhs, true);
-                    AssignBroadcast<ushort>(l, r);
-                    break;
-                }
-                case NPTypeCode.Int32:
-                {
+			    }
+			    case NPTypeCode.Int32:
+			    {
                     var (l, r)= GetIterators<int>(lhs, rhs, true);
                     AssignBroadcast<int>(l, r);
                     break;
-                }
-                case NPTypeCode.UInt32:
-                {
-                    var (l, r)= GetIterators<uint>(lhs, rhs, true);
-                    AssignBroadcast<uint>(l, r);
-                    break;
-                }
-                case NPTypeCode.Int64:
-                {
+			    }
+			    case NPTypeCode.Int64:
+			    {
                     var (l, r)= GetIterators<long>(lhs, rhs, true);
                     AssignBroadcast<long>(l, r);
                     break;
-                }
-                case NPTypeCode.UInt64:
-                {
-                    var (l, r)= GetIterators<ulong>(lhs, rhs, true);
-                    AssignBroadcast<ulong>(l, r);
-                    break;
-                }
-                case NPTypeCode.Char:
-                {
-                    var (l, r)= GetIterators<char>(lhs, rhs, true);
-                    AssignBroadcast<char>(l, r);
-                    break;
-                }
-                case NPTypeCode.Double:
-                {
-                    var (l, r)= GetIterators<double>(lhs, rhs, true);
-                    AssignBroadcast<double>(l, r);
-                    break;
-                }
-                case NPTypeCode.Single:
-                {
+			    }
+			    case NPTypeCode.Single:
+			    {
                     var (l, r)= GetIterators<float>(lhs, rhs, true);
                     AssignBroadcast<float>(l, r);
                     break;
-                }
-                case NPTypeCode.Decimal:
-                {
-                    var (l, r)= GetIterators<decimal>(lhs, rhs, true);
-                    AssignBroadcast<decimal>(l, r);
+			    }
+			    case NPTypeCode.Double:
+			    {
+                    var (l, r)= GetIterators<double>(lhs, rhs, true);
+                    AssignBroadcast<double>(l, r);
                     break;
-                }
-                default:
-                    throw new NotSupportedException();
-            }
+			    }
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
 #endif
         }
@@ -149,7 +113,7 @@ public static (NDIterator, NDIterator) GetIterators(UnmanagedStorage lhs, Unmana
             {
                 var (leftShape, rightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
 
-#if _REGEN
+#if _REGEN1
                 #region Compute
 		        switch (lhs.TypeCode)
 		        {
@@ -167,16 +131,10 @@ public static (NDIterator, NDIterator) GetIterators(UnmanagedStorage lhs, Unmana
 		        {
 			        case NPTypeCode.Boolean: return (new NDIterator<bool>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<bool>(rhs.InternalArray, rhs.Shape, rightShape, false));
 			        case NPTypeCode.Byte: return (new NDIterator<byte>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<byte>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.Int16: return (new NDIterator<short>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<short>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.UInt16: return (new NDIterator<ushort>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<ushort>(rhs.InternalArray, rhs.Shape, rightShape, false));
 			        case NPTypeCode.Int32: return (new NDIterator<int>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<int>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.UInt32: return (new NDIterator<uint>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<uint>(rhs.InternalArray, rhs.Shape, rightShape, false));
 			        case NPTypeCode.Int64: return (new NDIterator<long>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<long>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.UInt64: return (new NDIterator<ulong>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<ulong>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.Char: return (new NDIterator<char>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<char>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.Double: return (new NDIterator<double>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<double>(rhs.InternalArray, rhs.Shape, rightShape, false));
 			        case NPTypeCode.Single: return (new NDIterator<float>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<float>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.Decimal: return (new NDIterator<decimal>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<decimal>(rhs.InternalArray, rhs.Shape, rightShape, false));
+			        case NPTypeCode.Double: return (new NDIterator<double>(lhs.InternalArray, lhs.Shape, leftShape, false), new NDIterator<double>(rhs.InternalArray, rhs.Shape, rightShape, false));
 			        default:
 				        throw new NotSupportedException();
 		        }
@@ -185,7 +143,7 @@ public static (NDIterator, NDIterator) GetIterators(UnmanagedStorage lhs, Unmana
             }
             else
             {
-#if _REGEN
+#if _REGEN1
                 #region Compute
 		        switch (lhs.TypeCode)
 		        {
@@ -203,16 +161,10 @@ public static (NDIterator, NDIterator) GetIterators(UnmanagedStorage lhs, Unmana
 		        {
 			        case NPTypeCode.Boolean: return (new NDIterator<bool>(lhs, false), new NDIterator<bool>(false));
 			        case NPTypeCode.Byte: return (new NDIterator<byte>(lhs, false), new NDIterator<byte>(false));
-			        case NPTypeCode.Int16: return (new NDIterator<short>(lhs, false), new NDIterator<short>(false));
-			        case NPTypeCode.UInt16: return (new NDIterator<ushort>(lhs, false), new NDIterator<ushort>(false));
 			        case NPTypeCode.Int32: return (new NDIterator<int>(lhs, false), new NDIterator<int>(false));
-			        case NPTypeCode.UInt32: return (new NDIterator<uint>(lhs, false), new NDIterator<uint>(false));
 			        case NPTypeCode.Int64: return (new NDIterator<long>(lhs, false), new NDIterator<long>(false));
-			        case NPTypeCode.UInt64: return (new NDIterator<ulong>(lhs, false), new NDIterator<ulong>(false));
-			        case NPTypeCode.Char: return (new NDIterator<char>(lhs, false), new NDIterator<char>(false));
-			        case NPTypeCode.Double: return (new NDIterator<double>(lhs, false), new NDIterator<double>(false));
 			        case NPTypeCode.Single: return (new NDIterator<float>(lhs, false), new NDIterator<float>(false));
-			        case NPTypeCode.Decimal: return (new NDIterator<decimal>(lhs, false), new NDIterator<decimal>(false));
+			        case NPTypeCode.Double: return (new NDIterator<double>(lhs, false), new NDIterator<double>(false));
 			        default:
 				        throw new NotSupportedException();
 		        }
@@ -231,7 +183,7 @@ public static (NDIterator<TOut>, NDIterator<TOut>) GetIterators<TOut>(UnmanagedS
             {
                 var (leftShape, rightShape) = lhs.Shape == rhs.Shape ? (lhs.Shape, rhs.Shape) : DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
 
-#if _REGEN
+#if _REGEN1
                 #region Compute
 		        switch (InfoOf<TOut>.NPTypeCode)
 		        {
@@ -249,16 +201,10 @@ public static (NDIterator<TOut>, NDIterator<TOut>) GetIterators<TOut>(UnmanagedS
 		        {
 			        case NPTypeCode.Boolean: return ((NDIterator<TOut>)(object)new NDIterator<bool>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<bool>(rhs.InternalArray, rhs.Shape, rightShape, false));
 			        case NPTypeCode.Byte: return ((NDIterator<TOut>)(object)new NDIterator<byte>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<byte>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.Int16: return ((NDIterator<TOut>)(object)new NDIterator<short>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<short>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.UInt16: return ((NDIterator<TOut>)(object)new NDIterator<ushort>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<ushort>(rhs.InternalArray, rhs.Shape, rightShape, false));
 			        case NPTypeCode.Int32: return ((NDIterator<TOut>)(object)new NDIterator<int>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<int>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.UInt32: return ((NDIterator<TOut>)(object)new NDIterator<uint>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<uint>(rhs.InternalArray, rhs.Shape, rightShape, false));
 			        case NPTypeCode.Int64: return ((NDIterator<TOut>)(object)new NDIterator<long>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<long>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.UInt64: return ((NDIterator<TOut>)(object)new NDIterator<ulong>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<ulong>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.Char: return ((NDIterator<TOut>)(object)new NDIterator<char>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<char>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.Double: return ((NDIterator<TOut>)(object)new NDIterator<double>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<double>(rhs.InternalArray, rhs.Shape, rightShape, false));
 			        case NPTypeCode.Single: return ((NDIterator<TOut>)(object)new NDIterator<float>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<float>(rhs.InternalArray, rhs.Shape, rightShape, false));
-			        case NPTypeCode.Decimal: return ((NDIterator<TOut>)(object)new NDIterator<decimal>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<decimal>(rhs.InternalArray, rhs.Shape, rightShape, false));
+			        case NPTypeCode.Double: return ((NDIterator<TOut>)(object)new NDIterator<double>(lhs.InternalArray, lhs.Shape, leftShape, false), (NDIterator<TOut>)(object)new NDIterator<double>(rhs.InternalArray, rhs.Shape, rightShape, false));
 			        default:
 				        throw new NotSupportedException();
 		        }
@@ -267,7 +213,7 @@ public static (NDIterator<TOut>, NDIterator<TOut>) GetIterators<TOut>(UnmanagedS
             }
             else
             {
-#if _REGEN
+#if _REGEN1
                 #region Compute
 		        switch (lhs.TypeCode)
 		        {
@@ -285,16 +231,10 @@ public static (NDIterator<TOut>, NDIterator<TOut>) GetIterators<TOut>(UnmanagedS
 		        {
 			        case NPTypeCode.Boolean: return ((NDIterator<TOut>)(object)new NDIterator<bool>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<bool>(false));
 			        case NPTypeCode.Byte: return ((NDIterator<TOut>)(object)new NDIterator<byte>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<byte>(false));
-			        case NPTypeCode.Int16: return ((NDIterator<TOut>)(object)new NDIterator<short>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<short>(false));
-			        case NPTypeCode.UInt16: return ((NDIterator<TOut>)(object)new NDIterator<ushort>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<ushort>(false));
 			        case NPTypeCode.Int32: return ((NDIterator<TOut>)(object)new NDIterator<int>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<int>(false));
-			        case NPTypeCode.UInt32: return ((NDIterator<TOut>)(object)new NDIterator<uint>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<uint>(false));
 			        case NPTypeCode.Int64: return ((NDIterator<TOut>)(object)new NDIterator<long>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<long>(false));
-			        case NPTypeCode.UInt64: return ((NDIterator<TOut>)(object)new NDIterator<ulong>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<ulong>(false));
-			        case NPTypeCode.Char: return ((NDIterator<TOut>)(object)new NDIterator<char>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<char>(false));
-			        case NPTypeCode.Double: return ((NDIterator<TOut>)(object)new NDIterator<double>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<double>(false));
 			        case NPTypeCode.Single: return ((NDIterator<TOut>)(object)new NDIterator<float>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<float>(false));
-			        case NPTypeCode.Decimal: return ((NDIterator<TOut>)(object)new NDIterator<decimal>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<decimal>(false));
+			        case NPTypeCode.Double: return ((NDIterator<TOut>)(object)new NDIterator<double>(lhs, false), (NDIterator<TOut>)(object)new NDIterator<double>(false));
 			        default:
 				        throw new NotSupportedException();
 		        }
diff --git a/src/NumSharp.Core/Backends/Iterators/NDIterator.cs b/src/NumSharp.Core/Backends/Iterators/NDIterator.cs
index a6d301d9d..3d8e38eaa 100644
--- a/src/NumSharp.Core/Backends/Iterators/NDIterator.cs
+++ b/src/NumSharp.Core/Backends/Iterators/NDIterator.cs
@@ -109,7 +109,7 @@ public void SetMode(bool autoreset, Shape reshape = default)
         protected void SetDefaults()
         {
 
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (Block.TypeCode)
 		    {
@@ -126,16 +126,10 @@ protected void SetDefaults()
 		    {
 			    case NPTypeCode.Boolean: setDefaults_Boolean(); break;
 			    case NPTypeCode.Byte: setDefaults_Byte(); break;
-			    case NPTypeCode.Int16: setDefaults_Int16(); break;
-			    case NPTypeCode.UInt16: setDefaults_UInt16(); break;
 			    case NPTypeCode.Int32: setDefaults_Int32(); break;
-			    case NPTypeCode.UInt32: setDefaults_UInt32(); break;
 			    case NPTypeCode.Int64: setDefaults_Int64(); break;
-			    case NPTypeCode.UInt64: setDefaults_UInt64(); break;
-			    case NPTypeCode.Char: setDefaults_Char(); break;
-			    case NPTypeCode.Double: setDefaults_Double(); break;
 			    case NPTypeCode.Single: setDefaults_Single(); break;
-			    case NPTypeCode.Decimal: setDefaults_Decimal(); break;
+			    case NPTypeCode.Double: setDefaults_Double(); break;
 			    default:
 				    throw new NotSupportedException();
 		    }
diff --git a/src/NumSharp.Core/Backends/Iterators/NDIteratorExtensions.cs b/src/NumSharp.Core/Backends/Iterators/NDIteratorExtensions.cs
index 25045f978..40407df27 100644
--- a/src/NumSharp.Core/Backends/Iterators/NDIteratorExtensions.cs
+++ b/src/NumSharp.Core/Backends/Iterators/NDIteratorExtensions.cs
@@ -28,7 +28,7 @@ public static NDIterator<T> AsIterator<T>(this NDArray nd, bool autoreset = fals
         /// <param name="autoreset">Should this iterator loop forever?</param>
         public static NDIterator AsIterator(this NDArray nd, bool autoreset = false)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (nd.GetTypeCode)
 		    {
@@ -42,27 +42,18 @@ public static NDIterator AsIterator(this NDArray nd, bool autoreset = false)
 #else
 
             #region Compute
-
-            switch (nd.GetTypeCode)
-            {
-                case NPTypeCode.Boolean: return new NDIterator<bool>(nd, autoreset);
-                case NPTypeCode.Byte: return new NDIterator<byte>(nd, autoreset);
-                case NPTypeCode.Int16: return new NDIterator<short>(nd, autoreset);
-                case NPTypeCode.UInt16: return new NDIterator<ushort>(nd, autoreset);
-                case NPTypeCode.Int32: return new NDIterator<int>(nd, autoreset);
-                case NPTypeCode.UInt32: return new NDIterator<uint>(nd, autoreset);
-                case NPTypeCode.Int64: return new NDIterator<long>(nd, autoreset);
-                case NPTypeCode.UInt64: return new NDIterator<ulong>(nd, autoreset);
-                case NPTypeCode.Char: return new NDIterator<char>(nd, autoreset);
-                case NPTypeCode.Double: return new NDIterator<double>(nd, autoreset);
-                case NPTypeCode.Single: return new NDIterator<float>(nd, autoreset);
-                case NPTypeCode.Decimal: return new NDIterator<decimal>(nd, autoreset);
-                default:
-                    throw new NotSupportedException();
-            }
-
+		    switch (nd.GetTypeCode)
+		    {
+			    case NPTypeCode.Boolean: return new NDIterator<bool>(nd, autoreset);
+			    case NPTypeCode.Byte: return new NDIterator<byte>(nd, autoreset);
+			    case NPTypeCode.Int32: return new NDIterator<int>(nd, autoreset);
+			    case NPTypeCode.Int64: return new NDIterator<long>(nd, autoreset);
+			    case NPTypeCode.Single: return new NDIterator<float>(nd, autoreset);
+			    case NPTypeCode.Double: return new NDIterator<double>(nd, autoreset);
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
 
@@ -74,7 +65,7 @@ public static NDIterator AsIterator(this NDArray nd, bool autoreset = false)
         /// <param name="autoreset">Should this iterator loop forever?</param>
         public static NDIterator AsIterator(this UnmanagedStorage us, bool autoreset = false)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (us.TypeCode)
 		    {
@@ -88,27 +79,18 @@ public static NDIterator AsIterator(this UnmanagedStorage us, bool autoreset = f
 #else
 
             #region Compute
-
-            switch (us.TypeCode)
-            {
-                case NPTypeCode.Boolean: return new NDIterator<bool>(us, autoreset);
-                case NPTypeCode.Byte: return new NDIterator<byte>(us, autoreset);
-                case NPTypeCode.Int16: return new NDIterator<short>(us, autoreset);
-                case NPTypeCode.UInt16: return new NDIterator<ushort>(us, autoreset);
-                case NPTypeCode.Int32: return new NDIterator<int>(us, autoreset);
-                case NPTypeCode.UInt32: return new NDIterator<uint>(us, autoreset);
-                case NPTypeCode.Int64: return new NDIterator<long>(us, autoreset);
-                case NPTypeCode.UInt64: return new NDIterator<ulong>(us, autoreset);
-                case NPTypeCode.Char: return new NDIterator<char>(us, autoreset);
-                case NPTypeCode.Double: return new NDIterator<double>(us, autoreset);
-                case NPTypeCode.Single: return new NDIterator<float>(us, autoreset);
-                case NPTypeCode.Decimal: return new NDIterator<decimal>(us, autoreset);
-                default:
-                    throw new NotSupportedException();
-            }
-
+		    switch (us.TypeCode)
+		    {
+			    case NPTypeCode.Boolean: return new NDIterator<bool>(us, autoreset);
+			    case NPTypeCode.Byte: return new NDIterator<byte>(us, autoreset);
+			    case NPTypeCode.Int32: return new NDIterator<int>(us, autoreset);
+			    case NPTypeCode.Int64: return new NDIterator<long>(us, autoreset);
+			    case NPTypeCode.Single: return new NDIterator<float>(us, autoreset);
+			    case NPTypeCode.Double: return new NDIterator<double>(us, autoreset);
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
 
@@ -120,7 +102,7 @@ public static NDIterator AsIterator(this UnmanagedStorage us, bool autoreset = f
         /// <param name="autoreset">Should this iterator loop forever?</param>
         public static NDIterator AsIterator(this IArraySlice arr, Shape shape)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (arr.TypeCode)
 		    {
@@ -134,27 +116,18 @@ public static NDIterator AsIterator(this IArraySlice arr, Shape shape)
 #else
 
             #region Compute
-
-            switch (arr.TypeCode)
-            {
-                case NPTypeCode.Boolean: return new NDIterator<bool>(arr, shape, null);
-                case NPTypeCode.Byte: return new NDIterator<byte>(arr, shape, null);
-                case NPTypeCode.Int16: return new NDIterator<short>(arr, shape, null);
-                case NPTypeCode.UInt16: return new NDIterator<ushort>(arr, shape, null);
-                case NPTypeCode.Int32: return new NDIterator<int>(arr, shape, null);
-                case NPTypeCode.UInt32: return new NDIterator<uint>(arr, shape, null);
-                case NPTypeCode.Int64: return new NDIterator<long>(arr, shape, null);
-                case NPTypeCode.UInt64: return new NDIterator<ulong>(arr, shape, null);
-                case NPTypeCode.Char: return new NDIterator<char>(arr, shape, null);
-                case NPTypeCode.Double: return new NDIterator<double>(arr, shape, null);
-                case NPTypeCode.Single: return new NDIterator<float>(arr, shape, null);
-                case NPTypeCode.Decimal: return new NDIterator<decimal>(arr, shape, null);
-                default:
-                    throw new NotSupportedException();
-            }
-
+		    switch (arr.TypeCode)
+		    {
+			    case NPTypeCode.Boolean: return new NDIterator<bool>(arr, shape, null);
+			    case NPTypeCode.Byte: return new NDIterator<byte>(arr, shape, null);
+			    case NPTypeCode.Int32: return new NDIterator<int>(arr, shape, null);
+			    case NPTypeCode.Int64: return new NDIterator<long>(arr, shape, null);
+			    case NPTypeCode.Single: return new NDIterator<float>(arr, shape, null);
+			    case NPTypeCode.Double: return new NDIterator<double>(arr, shape, null);
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
 
@@ -167,7 +140,7 @@ public static NDIterator AsIterator(this IArraySlice arr, Shape shape)
         /// <param name="shape">The original shape, non-broadcasted, to represent this iterator.</param>
         public static NDIterator AsIterator(this IArraySlice arr, Shape shape, bool autoreset)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (arr.TypeCode)
 		    {
@@ -181,27 +154,18 @@ public static NDIterator AsIterator(this IArraySlice arr, Shape shape, bool auto
 #else
 
             #region Compute
-
-            switch (arr.TypeCode)
-            {
-                case NPTypeCode.Boolean: return new NDIterator<bool>(arr, shape, null, autoreset);
-                case NPTypeCode.Byte: return new NDIterator<byte>(arr, shape, null, autoreset);
-                case NPTypeCode.Int16: return new NDIterator<short>(arr, shape, null, autoreset);
-                case NPTypeCode.UInt16: return new NDIterator<ushort>(arr, shape, null, autoreset);
-                case NPTypeCode.Int32: return new NDIterator<int>(arr, shape, null, autoreset);
-                case NPTypeCode.UInt32: return new NDIterator<uint>(arr, shape, null, autoreset);
-                case NPTypeCode.Int64: return new NDIterator<long>(arr, shape, null, autoreset);
-                case NPTypeCode.UInt64: return new NDIterator<ulong>(arr, shape, null, autoreset);
-                case NPTypeCode.Char: return new NDIterator<char>(arr, shape, null, autoreset);
-                case NPTypeCode.Double: return new NDIterator<double>(arr, shape, null, autoreset);
-                case NPTypeCode.Single: return new NDIterator<float>(arr, shape, null, autoreset);
-                case NPTypeCode.Decimal: return new NDIterator<decimal>(arr, shape, null, autoreset);
-                default:
-                    throw new NotSupportedException();
-            }
-
+		    switch (arr.TypeCode)
+		    {
+			    case NPTypeCode.Boolean: return new NDIterator<bool>(arr, shape, null, autoreset);
+			    case NPTypeCode.Byte: return new NDIterator<byte>(arr, shape, null, autoreset);
+			    case NPTypeCode.Int32: return new NDIterator<int>(arr, shape, null, autoreset);
+			    case NPTypeCode.Int64: return new NDIterator<long>(arr, shape, null, autoreset);
+			    case NPTypeCode.Single: return new NDIterator<float>(arr, shape, null, autoreset);
+			    case NPTypeCode.Double: return new NDIterator<double>(arr, shape, null, autoreset);
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
         /// <summary>
@@ -214,7 +178,7 @@ public static NDIterator AsIterator(this IArraySlice arr, Shape shape, bool auto
         /// <param name="broadcastShape">The broadcasted shape of <paramref name="shape"/></param>
         public static NDIterator AsIterator(this IArraySlice arr, Shape shape, Shape broadcastShape, bool autoReset)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (arr.TypeCode)
 		    {
@@ -228,27 +192,18 @@ public static NDIterator AsIterator(this IArraySlice arr, Shape shape, Shape bro
 #else
 
             #region Compute
-
-            switch (arr.TypeCode)
-            {
-                case NPTypeCode.Boolean: return new NDIterator<bool>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.Byte: return new NDIterator<byte>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.Int16: return new NDIterator<short>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.UInt16: return new NDIterator<ushort>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.Int32: return new NDIterator<int>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.UInt32: return new NDIterator<uint>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.Int64: return new NDIterator<long>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.UInt64: return new NDIterator<ulong>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.Char: return new NDIterator<char>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.Double: return new NDIterator<double>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.Single: return new NDIterator<float>(arr, shape, broadcastShape, autoReset);
-                case NPTypeCode.Decimal: return new NDIterator<decimal>(arr, shape, broadcastShape, autoReset);
-                default:
-                    throw new NotSupportedException();
-            }
-
+		    switch (arr.TypeCode)
+		    {
+			    case NPTypeCode.Boolean: return new NDIterator<bool>(arr, shape, broadcastShape, autoReset);
+			    case NPTypeCode.Byte: return new NDIterator<byte>(arr, shape, broadcastShape, autoReset);
+			    case NPTypeCode.Int32: return new NDIterator<int>(arr, shape, broadcastShape, autoReset);
+			    case NPTypeCode.Int64: return new NDIterator<long>(arr, shape, broadcastShape, autoReset);
+			    case NPTypeCode.Single: return new NDIterator<float>(arr, shape, broadcastShape, autoReset);
+			    case NPTypeCode.Double: return new NDIterator<double>(arr, shape, broadcastShape, autoReset);
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
     }
diff --git a/src/NumSharp.Core/Backends/NDArray.Unmanaged.cs b/src/NumSharp.Core/Backends/NDArray.Unmanaged.cs
index dfe27dcf4..965a66f8a 100644
--- a/src/NumSharp.Core/Backends/NDArray.Unmanaged.cs
+++ b/src/NumSharp.Core/Backends/NDArray.Unmanaged.cs
@@ -149,7 +149,7 @@ public unsafe ref T GetPin<T>()
                     return ref CompilerUnsafe.AsRef<T>(_this.Address);
                 }
 
-#if _REGEN
+#if _REGEN1
                 #region Compute
 		        %foreach supported_dtypes,supported_dtypes_lowercase%
                 /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
@@ -187,26 +187,6 @@ public unsafe ref byte Byte
                     }
                 } 
 
-                /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
-		        public unsafe ref short Int16
-                {
-                    get
-                    {
-                        if (_this.Shape.IsSliced || _this.Shape.IsBroadcasted) throw new InvalidOperationException("Can't pin reference when NDArray is sliced or broadcasted.");
-                        return ref CompilerUnsafe.AsRef<short>(_this.Address);
-                    }
-                } 
-
-                /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
-		        public unsafe ref ushort UInt16
-                {
-                    get
-                    {
-                        if (_this.Shape.IsSliced || _this.Shape.IsBroadcasted) throw new InvalidOperationException("Can't pin reference when NDArray is sliced or broadcasted.");
-                        return ref CompilerUnsafe.AsRef<ushort>(_this.Address);
-                    }
-                } 
-
                 /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
 		        public unsafe ref int Int32
                 {
@@ -217,16 +197,6 @@ public unsafe ref int Int32
                     }
                 } 
 
-                /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
-		        public unsafe ref uint UInt32
-                {
-                    get
-                    {
-                        if (_this.Shape.IsSliced || _this.Shape.IsBroadcasted) throw new InvalidOperationException("Can't pin reference when NDArray is sliced or broadcasted.");
-                        return ref CompilerUnsafe.AsRef<uint>(_this.Address);
-                    }
-                } 
-
                 /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
 		        public unsafe ref long Int64
                 {
@@ -237,36 +207,6 @@ public unsafe ref long Int64
                     }
                 } 
 
-                /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
-		        public unsafe ref ulong UInt64
-                {
-                    get
-                    {
-                        if (_this.Shape.IsSliced || _this.Shape.IsBroadcasted) throw new InvalidOperationException("Can't pin reference when NDArray is sliced or broadcasted.");
-                        return ref CompilerUnsafe.AsRef<ulong>(_this.Address);
-                    }
-                } 
-
-                /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
-		        public unsafe ref char Char
-                {
-                    get
-                    {
-                        if (_this.Shape.IsSliced || _this.Shape.IsBroadcasted) throw new InvalidOperationException("Can't pin reference when NDArray is sliced or broadcasted.");
-                        return ref CompilerUnsafe.AsRef<char>(_this.Address);
-                    }
-                } 
-
-                /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
-		        public unsafe ref double Double
-                {
-                    get
-                    {
-                        if (_this.Shape.IsSliced || _this.Shape.IsBroadcasted) throw new InvalidOperationException("Can't pin reference when NDArray is sliced or broadcasted.");
-                        return ref CompilerUnsafe.AsRef<double>(_this.Address);
-                    }
-                } 
-
                 /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
 		        public unsafe ref float Single
                 {
@@ -278,12 +218,12 @@ public unsafe ref float Single
                 } 
 
                 /// <exception cref="InvalidOperationException">When this NDArray is a slice.</exception>
-		        public unsafe ref decimal Decimal
+		        public unsafe ref double Double
                 {
                     get
                     {
                         if (_this.Shape.IsSliced || _this.Shape.IsBroadcasted) throw new InvalidOperationException("Can't pin reference when NDArray is sliced or broadcasted.");
-                        return ref CompilerUnsafe.AsRef<decimal>(_this.Address);
+                        return ref CompilerUnsafe.AsRef<double>(_this.Address);
                     }
                 } 
 
diff --git a/src/NumSharp.Core/Backends/NDArray.cs b/src/NumSharp.Core/Backends/NDArray.cs
index 22f49bd9a..09322c98b 100644
--- a/src/NumSharp.Core/Backends/NDArray.cs
+++ b/src/NumSharp.Core/Backends/NDArray.cs
@@ -411,7 +411,7 @@ public IEnumerator GetEnumerator()
             if (Array == null || Shape.IsEmpty || Shape.size == 0)
                 return _empty().GetEnumerator();
 
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (GetTypeCode)
 		    {
@@ -425,27 +425,18 @@ public IEnumerator GetEnumerator()
 #else
 
             #region Compute
-
-            switch (GetTypeCode)
-            {
-                case NPTypeCode.Boolean: return new NDIterator<bool>(this, false).GetEnumerator();
-                case NPTypeCode.Byte: return new NDIterator<byte>(this, false).GetEnumerator();
-                case NPTypeCode.Int16: return new NDIterator<short>(this, false).GetEnumerator();
-                case NPTypeCode.UInt16: return new NDIterator<ushort>(this, false).GetEnumerator();
-                case NPTypeCode.Int32: return new NDIterator<int>(this, false).GetEnumerator();
-                case NPTypeCode.UInt32: return new NDIterator<uint>(this, false).GetEnumerator();
-                case NPTypeCode.Int64: return new NDIterator<long>(this, false).GetEnumerator();
-                case NPTypeCode.UInt64: return new NDIterator<ulong>(this, false).GetEnumerator();
-                case NPTypeCode.Char: return new NDIterator<char>(this, false).GetEnumerator();
-                case NPTypeCode.Double: return new NDIterator<double>(this, false).GetEnumerator();
-                case NPTypeCode.Single: return new NDIterator<float>(this, false).GetEnumerator();
-                case NPTypeCode.Decimal: return new NDIterator<decimal>(this, false).GetEnumerator();
-                default:
-                    throw new NotSupportedException();
-            }
-
+		    switch (GetTypeCode)
+		    {
+			    case NPTypeCode.Boolean: return new NDIterator<bool>(this, false).GetEnumerator();
+			    case NPTypeCode.Byte: return new NDIterator<byte>(this, false).GetEnumerator();
+			    case NPTypeCode.Int32: return new NDIterator<int>(this, false).GetEnumerator();
+			    case NPTypeCode.Int64: return new NDIterator<long>(this, false).GetEnumerator();
+			    case NPTypeCode.Single: return new NDIterator<float>(this, false).GetEnumerator();
+			    case NPTypeCode.Double: return new NDIterator<double>(this, false).GetEnumerator();
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
 
             IEnumerable _empty()
@@ -569,24 +560,6 @@ public NDArray[] GetNDArrays(int axis = 0)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public byte GetByte(params int[] indices) => Storage.GetByte(indices);
 
-        /// <summary>
-        ///     Retrieves value of type <see cref="char"/>.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="char"/></exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public char GetChar(params int[] indices) => Storage.GetChar(indices);
-
-        /// <summary>
-        ///     Retrieves value of type <see cref="decimal"/>.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="decimal"/></exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public decimal GetDecimal(params int[] indices) => Storage.GetDecimal(indices);
-
         /// <summary>
         ///     Retrieves value of type <see cref="double"/>.
         /// </summary>
@@ -596,15 +569,6 @@ public NDArray[] GetNDArrays(int axis = 0)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public double GetDouble(params int[] indices) => Storage.GetDouble(indices);
 
-        /// <summary>
-        ///     Retrieves value of type <see cref="short"/>.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="short"/></exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public short GetInt16(params int[] indices) => Storage.GetInt16(indices);
-
         /// <summary>
         ///     Retrieves value of type <see cref="int"/>.
         /// </summary>
@@ -632,33 +596,6 @@ public NDArray[] GetNDArrays(int axis = 0)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public float GetSingle(params int[] indices) => Storage.GetSingle(indices);
 
-        /// <summary>
-        ///     Retrieves value of type <see cref="ushort"/>.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="ushort"/></exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public ushort GetUInt16(params int[] indices) => Storage.GetUInt16(indices);
-
-        /// <summary>
-        ///     Retrieves value of type <see cref="uint"/>.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="uint"/></exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public uint GetUInt32(params int[] indices) => Storage.GetUInt32(indices);
-
-        /// <summary>
-        ///     Retrieves value of type <see cref="ulong"/>.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="ulong"/></exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public ulong GetUInt64(params int[] indices) => Storage.GetUInt64(indices);
-
         /// <summary>
         ///     Retrieves value of unspecified type (will figure using <see cref="DType"/>).
         /// </summary>
@@ -861,7 +798,7 @@ public void ReplaceData(IArraySlice values)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SetAtIndex<T>(T value, int index) where T : unmanaged => Storage.SetAtIndex(value, index);
 
-#if _REGEN
+#if _REGEN1
 	%foreach supported_dtypes,supported_dtypes_lowercase%
         /// <summary>
         ///     Sets a #2 at specific coordinates.
@@ -889,22 +826,6 @@ public void ReplaceData(IArraySlice values)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SetByte(byte value, params int[] indices) => Storage.SetByte(value, indices);
 
-        /// <summary>
-        ///     Sets a short at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetInt16(short value, params int[] indices) => Storage.SetInt16(value, indices);
-
-        /// <summary>
-        ///     Sets a ushort at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUInt16(ushort value, params int[] indices) => Storage.SetUInt16(value, indices);
-
         /// <summary>
         ///     Sets a int at specific coordinates.
         /// </summary>
@@ -913,14 +834,6 @@ public void ReplaceData(IArraySlice values)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SetInt32(int value, params int[] indices) => Storage.SetInt32(value, indices);
 
-        /// <summary>
-        ///     Sets a uint at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUInt32(uint value, params int[] indices) => Storage.SetUInt32(value, indices);
-
         /// <summary>
         ///     Sets a long at specific coordinates.
         /// </summary>
@@ -929,30 +842,6 @@ public void ReplaceData(IArraySlice values)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SetInt64(long value, params int[] indices) => Storage.SetInt64(value, indices);
 
-        /// <summary>
-        ///     Sets a ulong at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUInt64(ulong value, params int[] indices) => Storage.SetUInt64(value, indices);
-
-        /// <summary>
-        ///     Sets a char at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetChar(char value, params int[] indices) => Storage.SetChar(value, indices);
-
-        /// <summary>
-        ///     Sets a double at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetDouble(double value, params int[] indices) => Storage.SetDouble(value, indices);
-
         /// <summary>
         ///     Sets a float at specific coordinates.
         /// </summary>
@@ -962,12 +851,12 @@ public void ReplaceData(IArraySlice values)
         public void SetSingle(float value, params int[] indices) => Storage.SetSingle(value, indices);
 
         /// <summary>
-        ///     Sets a decimal at specific coordinates.
+        ///     Sets a double at specific coordinates.
         /// </summary>
         /// <param name="value">The values to assign</param>
         /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetDecimal(decimal value, params int[] indices) => Storage.SetDecimal(value, indices);
+        public void SetDouble(double value, params int[] indices) => Storage.SetDouble(value, indices);
 #endif
 
         #endregion
diff --git a/src/NumSharp.Core/Backends/NPTypeCode.cs b/src/NumSharp.Core/Backends/NPTypeCode.cs
index 6a1b2d040..a6de38949 100644
--- a/src/NumSharp.Core/Backends/NPTypeCode.cs
+++ b/src/NumSharp.Core/Backends/NPTypeCode.cs
@@ -125,29 +125,22 @@ public static Type AsType(this NPTypeCode typeCode)
         {
             switch (typeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach all_dtypes,all_dtypes_lowercase%
 	            case NPTypeCode.#1: return typeof(#2);
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Complex: return typeof(Complex);
-                case NPTypeCode.Boolean: return typeof(bool);
-                case NPTypeCode.Byte: return typeof(byte);
-                case NPTypeCode.Int16: return typeof(short);
-                case NPTypeCode.UInt16: return typeof(ushort);
-                case NPTypeCode.Int32: return typeof(int);
-                case NPTypeCode.UInt32: return typeof(uint);
-                case NPTypeCode.Int64: return typeof(long);
-                case NPTypeCode.UInt64: return typeof(ulong);
-                case NPTypeCode.Char: return typeof(char);
-                case NPTypeCode.Double: return typeof(double);
-                case NPTypeCode.Single: return typeof(float);
-                case NPTypeCode.Decimal: return typeof(decimal);
-                case NPTypeCode.String: return typeof(string);
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return typeof(bool);
+	            case NPTypeCode.Byte: return typeof(byte);
+	            case NPTypeCode.Int32: return typeof(int);
+	            case NPTypeCode.Int64: return typeof(long);
+	            case NPTypeCode.Single: return typeof(float);
+	            case NPTypeCode.Double: return typeof(double);
+	            case NPTypeCode.String: return typeof(string);
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -588,7 +581,7 @@ public static NPTypeCode GetComputingType(this NPTypeCode typeCode)
         /// <returns>dtype in case when statistics are computed like <see cref="np.sum"/></returns>
         public static NPTypeCode GetAccumulatingType(this NPTypeCode typeCode)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (typeCode)
 		    {
@@ -603,18 +596,11 @@ public static NPTypeCode GetAccumulatingType(this NPTypeCode typeCode)
             #region Compute
 		    switch (typeCode)
 		    {
-			    case NPTypeCode.Boolean: return NPTypeCode.Int32;
-			    case NPTypeCode.Byte: return NPTypeCode.UInt32;
-			    case NPTypeCode.Int16: return NPTypeCode.Int32;
-			    case NPTypeCode.UInt16: return NPTypeCode.UInt32;
-			    case NPTypeCode.Int32: return NPTypeCode.Int32;
-			    case NPTypeCode.UInt32: return NPTypeCode.UInt32;
-			    case NPTypeCode.Int64: return NPTypeCode.Int64;
-			    case NPTypeCode.UInt64: return NPTypeCode.UInt64;
-			    case NPTypeCode.Char: return NPTypeCode.UInt32;
-			    case NPTypeCode.Double: return NPTypeCode.Double;
-			    case NPTypeCode.Single: return NPTypeCode.Single;
-			    case NPTypeCode.Decimal: return NPTypeCode.Decimal;
+			    case NPTypeCode.Boolean: return NPTypeCode.Byte;
+			    case NPTypeCode.Byte: return NPTypeCode.Int32;
+			    case NPTypeCode.Int32: return NPTypeCode.Int64;
+			    case NPTypeCode.Int64: return NPTypeCode.Single;
+			    case NPTypeCode.Single: return NPTypeCode.Double;
 			    default:
 				    throw new NotSupportedException();
 		    }
@@ -629,7 +615,7 @@ public static NPTypeCode GetAccumulatingType(this NPTypeCode typeCode)
         /// </summary>
         public static ValueType GetDefaultValue(this NPTypeCode typeCode)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (typeCode)
 		    {
@@ -646,16 +632,10 @@ public static ValueType GetDefaultValue(this NPTypeCode typeCode)
 		    {
 			    case NPTypeCode.Boolean: return default(bool);
 			    case NPTypeCode.Byte: return default(byte);
-			    case NPTypeCode.Int16: return default(short);
-			    case NPTypeCode.UInt16: return default(ushort);
 			    case NPTypeCode.Int32: return default(int);
-			    case NPTypeCode.UInt32: return default(uint);
 			    case NPTypeCode.Int64: return default(long);
-			    case NPTypeCode.UInt64: return default(ulong);
-			    case NPTypeCode.Char: return default(char);
-			    case NPTypeCode.Double: return default(double);
 			    case NPTypeCode.Single: return default(float);
-			    case NPTypeCode.Decimal: return default(decimal);
+			    case NPTypeCode.Double: return default(double);
 			    default:
 				    throw new NotSupportedException();
 		    }
diff --git a/src/NumSharp.Core/Backends/Unmanaged/ArraySlice.cs b/src/NumSharp.Core/Backends/Unmanaged/ArraySlice.cs
index 29f41c0fd..9bf740a2a 100644
--- a/src/NumSharp.Core/Backends/Unmanaged/ArraySlice.cs
+++ b/src/NumSharp.Core/Backends/Unmanaged/ArraySlice.cs
@@ -18,7 +18,7 @@ public static IArraySlice Scalar(object val)
         {
             switch (val.GetType().GetTypeCode())
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return new ArraySlice<#1>(UnmanagedMemoryBlock<#1>.FromPool(_buffer)) {[0] = ((IConvertible)val).To#1(CultureInfo.InvariantCulture)};
 	            %
@@ -26,20 +26,14 @@ public static IArraySlice Scalar(object val)
 		            throw new NotSupportedException();
 #else
 
-                case NPTypeCode.Boolean: return new ArraySlice<Boolean>(UnmanagedMemoryBlock<Boolean>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToBoolean(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Byte: return new ArraySlice<Byte>(UnmanagedMemoryBlock<Byte>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToByte(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Int16: return new ArraySlice<Int16>(UnmanagedMemoryBlock<Int16>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToInt16(CultureInfo.InvariantCulture)};
-                case NPTypeCode.UInt16: return new ArraySlice<UInt16>(UnmanagedMemoryBlock<UInt16>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToUInt16(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Int32: return new ArraySlice<Int32>(UnmanagedMemoryBlock<Int32>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToInt32(CultureInfo.InvariantCulture)};
-                case NPTypeCode.UInt32: return new ArraySlice<UInt32>(UnmanagedMemoryBlock<UInt32>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToUInt32(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Int64: return new ArraySlice<Int64>(UnmanagedMemoryBlock<Int64>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToInt64(CultureInfo.InvariantCulture)};
-                case NPTypeCode.UInt64: return new ArraySlice<UInt64>(UnmanagedMemoryBlock<UInt64>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToUInt64(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Char: return new ArraySlice<Char>(UnmanagedMemoryBlock<Char>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToChar(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Double: return new ArraySlice<Double>(UnmanagedMemoryBlock<Double>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToDouble(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Single: return new ArraySlice<Single>(UnmanagedMemoryBlock<Single>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToSingle(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Decimal: return new ArraySlice<Decimal>(UnmanagedMemoryBlock<Decimal>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToDecimal(CultureInfo.InvariantCulture)};
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return new ArraySlice<Boolean>(UnmanagedMemoryBlock<Boolean>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToBoolean(CultureInfo.InvariantCulture)};
+	            case NPTypeCode.Byte: return new ArraySlice<Byte>(UnmanagedMemoryBlock<Byte>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToByte(CultureInfo.InvariantCulture)};
+	            case NPTypeCode.Int32: return new ArraySlice<Int32>(UnmanagedMemoryBlock<Int32>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToInt32(CultureInfo.InvariantCulture)};
+	            case NPTypeCode.Int64: return new ArraySlice<Int64>(UnmanagedMemoryBlock<Int64>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToInt64(CultureInfo.InvariantCulture)};
+	            case NPTypeCode.Single: return new ArraySlice<Single>(UnmanagedMemoryBlock<Single>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToSingle(CultureInfo.InvariantCulture)};
+	            case NPTypeCode.Double: return new ArraySlice<Double>(UnmanagedMemoryBlock<Double>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToDouble(CultureInfo.InvariantCulture)};
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -54,7 +48,7 @@ public static IArraySlice Scalar(object val, NPTypeCode typeCode)
         {
             switch (typeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return new ArraySlice<#1>(UnmanagedMemoryBlock<#1>.FromPool(_buffer)) {[0] = ((IConvertible)val).To#1(CultureInfo.InvariantCulture)};
 	            %
@@ -62,20 +56,14 @@ public static IArraySlice Scalar(object val, NPTypeCode typeCode)
 		            throw new NotSupportedException();
 #else
 
-                case NPTypeCode.Boolean: return new ArraySlice<Boolean>(UnmanagedMemoryBlock<Boolean>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToBoolean(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Byte: return new ArraySlice<Byte>(UnmanagedMemoryBlock<Byte>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToByte(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Int16: return new ArraySlice<Int16>(UnmanagedMemoryBlock<Int16>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToInt16(CultureInfo.InvariantCulture)};
-                case NPTypeCode.UInt16: return new ArraySlice<UInt16>(UnmanagedMemoryBlock<UInt16>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToUInt16(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Int32: return new ArraySlice<Int32>(UnmanagedMemoryBlock<Int32>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToInt32(CultureInfo.InvariantCulture)};
-                case NPTypeCode.UInt32: return new ArraySlice<UInt32>(UnmanagedMemoryBlock<UInt32>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToUInt32(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Int64: return new ArraySlice<Int64>(UnmanagedMemoryBlock<Int64>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToInt64(CultureInfo.InvariantCulture)};
-                case NPTypeCode.UInt64: return new ArraySlice<UInt64>(UnmanagedMemoryBlock<UInt64>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToUInt64(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Char: return new ArraySlice<Char>(UnmanagedMemoryBlock<Char>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToChar(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Double: return new ArraySlice<Double>(UnmanagedMemoryBlock<Double>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToDouble(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Single: return new ArraySlice<Single>(UnmanagedMemoryBlock<Single>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToSingle(CultureInfo.InvariantCulture)};
-                case NPTypeCode.Decimal: return new ArraySlice<Decimal>(UnmanagedMemoryBlock<Decimal>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToDecimal(CultureInfo.InvariantCulture)};
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return new ArraySlice<Boolean>(UnmanagedMemoryBlock<Boolean>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToBoolean(CultureInfo.InvariantCulture)};
+	            case NPTypeCode.Byte: return new ArraySlice<Byte>(UnmanagedMemoryBlock<Byte>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToByte(CultureInfo.InvariantCulture)};
+	            case NPTypeCode.Int32: return new ArraySlice<Int32>(UnmanagedMemoryBlock<Int32>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToInt32(CultureInfo.InvariantCulture)};
+	            case NPTypeCode.Int64: return new ArraySlice<Int64>(UnmanagedMemoryBlock<Int64>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToInt64(CultureInfo.InvariantCulture)};
+	            case NPTypeCode.Single: return new ArraySlice<Single>(UnmanagedMemoryBlock<Single>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToSingle(CultureInfo.InvariantCulture)};
+	            case NPTypeCode.Double: return new ArraySlice<Double>(UnmanagedMemoryBlock<Double>.FromPool(_buffer)) {[0] = ((IConvertible)val).ToDouble(CultureInfo.InvariantCulture)};
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -210,27 +198,21 @@ public static IArraySlice FromArray(Array arr, bool copy = false)
 
             switch (elementType.GetTypeCode())
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return new ArraySlice<#2>(UnmanagedMemoryBlock<#2>.FromArray(copy ? (#2[])arr.Clone() : (#2[])arr));
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return new ArraySlice<bool>(UnmanagedMemoryBlock<bool>.FromArray(copy ? (bool[])arr.Clone() : (bool[])arr));
-                case NPTypeCode.Byte: return new ArraySlice<byte>(UnmanagedMemoryBlock<byte>.FromArray(copy ? (byte[])arr.Clone() : (byte[])arr));
-                case NPTypeCode.Int16: return new ArraySlice<short>(UnmanagedMemoryBlock<short>.FromArray(copy ? (short[])arr.Clone() : (short[])arr));
-                case NPTypeCode.UInt16: return new ArraySlice<ushort>(UnmanagedMemoryBlock<ushort>.FromArray(copy ? (ushort[])arr.Clone() : (ushort[])arr));
-                case NPTypeCode.Int32: return new ArraySlice<int>(UnmanagedMemoryBlock<int>.FromArray(copy ? (int[])arr.Clone() : (int[])arr));
-                case NPTypeCode.UInt32: return new ArraySlice<uint>(UnmanagedMemoryBlock<uint>.FromArray(copy ? (uint[])arr.Clone() : (uint[])arr));
-                case NPTypeCode.Int64: return new ArraySlice<long>(UnmanagedMemoryBlock<long>.FromArray(copy ? (long[])arr.Clone() : (long[])arr));
-                case NPTypeCode.UInt64: return new ArraySlice<ulong>(UnmanagedMemoryBlock<ulong>.FromArray(copy ? (ulong[])arr.Clone() : (ulong[])arr));
-                case NPTypeCode.Char: return new ArraySlice<char>(UnmanagedMemoryBlock<char>.FromArray(copy ? (char[])arr.Clone() : (char[])arr));
-                case NPTypeCode.Double: return new ArraySlice<double>(UnmanagedMemoryBlock<double>.FromArray(copy ? (double[])arr.Clone() : (double[])arr));
-                case NPTypeCode.Single: return new ArraySlice<float>(UnmanagedMemoryBlock<float>.FromArray(copy ? (float[])arr.Clone() : (float[])arr));
-                case NPTypeCode.Decimal: return new ArraySlice<decimal>(UnmanagedMemoryBlock<decimal>.FromArray(copy ? (decimal[])arr.Clone() : (decimal[])arr));
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return new ArraySlice<bool>(UnmanagedMemoryBlock<bool>.FromArray(copy ? (bool[])arr.Clone() : (bool[])arr));
+	            case NPTypeCode.Byte: return new ArraySlice<byte>(UnmanagedMemoryBlock<byte>.FromArray(copy ? (byte[])arr.Clone() : (byte[])arr));
+	            case NPTypeCode.Int32: return new ArraySlice<int>(UnmanagedMemoryBlock<int>.FromArray(copy ? (int[])arr.Clone() : (int[])arr));
+	            case NPTypeCode.Int64: return new ArraySlice<long>(UnmanagedMemoryBlock<long>.FromArray(copy ? (long[])arr.Clone() : (long[])arr));
+	            case NPTypeCode.Single: return new ArraySlice<float>(UnmanagedMemoryBlock<float>.FromArray(copy ? (float[])arr.Clone() : (float[])arr));
+	            case NPTypeCode.Double: return new ArraySlice<double>(UnmanagedMemoryBlock<double>.FromArray(copy ? (double[])arr.Clone() : (double[])arr));
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -247,7 +229,7 @@ public static IArraySlice FromMemoryBlock(IMemoryBlock block, bool copy = false)
 
                 switch (type.GetGenericArguments()[0].GetTypeCode())
                 {
-#if _REGEN
+#if _REGEN1
 	                %foreach supported_dtypes,supported_dtypes_lowercase%
 	                case NPTypeCode.#1: return new ArraySlice<#2>(copy ? ((UnmanagedMemoryBlock<#2>)block).Clone() : (UnmanagedMemoryBlock<#2>)block);
 	                %
@@ -255,70 +237,52 @@ public static IArraySlice FromMemoryBlock(IMemoryBlock block, bool copy = false)
 		                throw new NotSupportedException();
 #else
 
-                    case NPTypeCode.Boolean: return new ArraySlice<bool>(copy ? ((UnmanagedMemoryBlock<bool>)block).Clone() : (UnmanagedMemoryBlock<bool>)block);
-                    case NPTypeCode.Byte: return new ArraySlice<byte>(copy ? ((UnmanagedMemoryBlock<byte>)block).Clone() : (UnmanagedMemoryBlock<byte>)block);
-                    case NPTypeCode.Int16: return new ArraySlice<short>(copy ? ((UnmanagedMemoryBlock<short>)block).Clone() : (UnmanagedMemoryBlock<short>)block);
-                    case NPTypeCode.UInt16: return new ArraySlice<ushort>(copy ? ((UnmanagedMemoryBlock<ushort>)block).Clone() : (UnmanagedMemoryBlock<ushort>)block);
-                    case NPTypeCode.Int32: return new ArraySlice<int>(copy ? ((UnmanagedMemoryBlock<int>)block).Clone() : (UnmanagedMemoryBlock<int>)block);
-                    case NPTypeCode.UInt32: return new ArraySlice<uint>(copy ? ((UnmanagedMemoryBlock<uint>)block).Clone() : (UnmanagedMemoryBlock<uint>)block);
-                    case NPTypeCode.Int64: return new ArraySlice<long>(copy ? ((UnmanagedMemoryBlock<long>)block).Clone() : (UnmanagedMemoryBlock<long>)block);
-                    case NPTypeCode.UInt64: return new ArraySlice<ulong>(copy ? ((UnmanagedMemoryBlock<ulong>)block).Clone() : (UnmanagedMemoryBlock<ulong>)block);
-                    case NPTypeCode.Char: return new ArraySlice<char>(copy ? ((UnmanagedMemoryBlock<char>)block).Clone() : (UnmanagedMemoryBlock<char>)block);
-                    case NPTypeCode.Double: return new ArraySlice<double>(copy ? ((UnmanagedMemoryBlock<double>)block).Clone() : (UnmanagedMemoryBlock<double>)block);
-                    case NPTypeCode.Single: return new ArraySlice<float>(copy ? ((UnmanagedMemoryBlock<float>)block).Clone() : (UnmanagedMemoryBlock<float>)block);
-                    case NPTypeCode.Decimal: return new ArraySlice<decimal>(copy ? ((UnmanagedMemoryBlock<decimal>)block).Clone() : (UnmanagedMemoryBlock<decimal>)block);
-                    default:
-                        throw new NotSupportedException();
+	                case NPTypeCode.Boolean: return new ArraySlice<bool>(copy ? ((UnmanagedMemoryBlock<bool>)block).Clone() : (UnmanagedMemoryBlock<bool>)block);
+	                case NPTypeCode.Byte: return new ArraySlice<byte>(copy ? ((UnmanagedMemoryBlock<byte>)block).Clone() : (UnmanagedMemoryBlock<byte>)block);
+	                case NPTypeCode.Int32: return new ArraySlice<int>(copy ? ((UnmanagedMemoryBlock<int>)block).Clone() : (UnmanagedMemoryBlock<int>)block);
+	                case NPTypeCode.Int64: return new ArraySlice<long>(copy ? ((UnmanagedMemoryBlock<long>)block).Clone() : (UnmanagedMemoryBlock<long>)block);
+	                case NPTypeCode.Single: return new ArraySlice<float>(copy ? ((UnmanagedMemoryBlock<float>)block).Clone() : (UnmanagedMemoryBlock<float>)block);
+	                case NPTypeCode.Double: return new ArraySlice<double>(copy ? ((UnmanagedMemoryBlock<double>)block).Clone() : (UnmanagedMemoryBlock<double>)block);
+	                default:
+		                throw new NotSupportedException();
 #endif
                 }
 
             throw new NotSupportedException($"IMemoryBlock of type {block.GetType().Name} is not supported for ArraySlice.FromMemoryBlock(...)");
         }
 
-#if _REGEN
+#if _REGEN1
         %foreach supported_dtypes,supported_dtypes_lowercase%
         public static ArraySlice<#2> FromArray(#2[] #2s, bool copy = false) => new ArraySlice<#2>(UnmanagedMemoryBlock<#2>.FromArray(#2s, copy));
         %
 #else
         public static ArraySlice<bool> FromArray(bool[] bools, bool copy = false) => new ArraySlice<bool>(UnmanagedMemoryBlock<bool>.FromArray(bools, copy));
         public static ArraySlice<byte> FromArray(byte[] bytes, bool copy = false) => new ArraySlice<byte>(UnmanagedMemoryBlock<byte>.FromArray(bytes, copy));
-        public static ArraySlice<short> FromArray(short[] shorts, bool copy = false) => new ArraySlice<short>(UnmanagedMemoryBlock<short>.FromArray(shorts, copy));
-        public static ArraySlice<ushort> FromArray(ushort[] ushorts, bool copy = false) => new ArraySlice<ushort>(UnmanagedMemoryBlock<ushort>.FromArray(ushorts, copy));
         public static ArraySlice<int> FromArray(int[] ints, bool copy = false) => new ArraySlice<int>(UnmanagedMemoryBlock<int>.FromArray(ints, copy));
-        public static ArraySlice<uint> FromArray(uint[] uints, bool copy = false) => new ArraySlice<uint>(UnmanagedMemoryBlock<uint>.FromArray(uints, copy));
         public static ArraySlice<long> FromArray(long[] longs, bool copy = false) => new ArraySlice<long>(UnmanagedMemoryBlock<long>.FromArray(longs, copy));
-        public static ArraySlice<ulong> FromArray(ulong[] ulongs, bool copy = false) => new ArraySlice<ulong>(UnmanagedMemoryBlock<ulong>.FromArray(ulongs, copy));
-        public static ArraySlice<char> FromArray(char[] chars, bool copy = false) => new ArraySlice<char>(UnmanagedMemoryBlock<char>.FromArray(chars, copy));
-        public static ArraySlice<double> FromArray(double[] doubles, bool copy = false) => new ArraySlice<double>(UnmanagedMemoryBlock<double>.FromArray(doubles, copy));
         public static ArraySlice<float> FromArray(float[] floats, bool copy = false) => new ArraySlice<float>(UnmanagedMemoryBlock<float>.FromArray(floats, copy));
-        public static ArraySlice<decimal> FromArray(decimal[] decimals, bool copy = false) => new ArraySlice<decimal>(UnmanagedMemoryBlock<decimal>.FromArray(decimals, copy));
+        public static ArraySlice<double> FromArray(double[] doubles, bool copy = false) => new ArraySlice<double>(UnmanagedMemoryBlock<double>.FromArray(doubles, copy));
 #endif
 
         public static IArraySlice Allocate(Type elementType, int count, object fill)
         {
             switch (elementType.GetTypeCode())
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return new ArraySlice<#2>(new UnmanagedMemoryBlock<#2>(count, ((IConvertible)fill).To#1(CultureInfo.InvariantCulture)));
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count, ((IConvertible)fill).ToBoolean(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count, ((IConvertible)fill).ToByte(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Int16: return new ArraySlice<short>(new UnmanagedMemoryBlock<short>(count, ((IConvertible)fill).ToInt16(CultureInfo.InvariantCulture)));
-                case NPTypeCode.UInt16: return new ArraySlice<ushort>(new UnmanagedMemoryBlock<ushort>(count, ((IConvertible)fill).ToUInt16(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count, ((IConvertible)fill).ToInt32(CultureInfo.InvariantCulture)));
-                case NPTypeCode.UInt32: return new ArraySlice<uint>(new UnmanagedMemoryBlock<uint>(count, ((IConvertible)fill).ToUInt32(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count, ((IConvertible)fill).ToInt64(CultureInfo.InvariantCulture)));
-                case NPTypeCode.UInt64: return new ArraySlice<ulong>(new UnmanagedMemoryBlock<ulong>(count, ((IConvertible)fill).ToUInt64(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Char: return new ArraySlice<char>(new UnmanagedMemoryBlock<char>(count, ((IConvertible)fill).ToChar(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count, ((IConvertible)fill).ToDouble(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count, ((IConvertible)fill).ToSingle(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Decimal: return new ArraySlice<decimal>(new UnmanagedMemoryBlock<decimal>(count, ((IConvertible)fill).ToDecimal(CultureInfo.InvariantCulture)));
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count, ((IConvertible)fill).ToBoolean(CultureInfo.InvariantCulture)));
+	            case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count, ((IConvertible)fill).ToByte(CultureInfo.InvariantCulture)));
+	            case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count, ((IConvertible)fill).ToInt32(CultureInfo.InvariantCulture)));
+	            case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count, ((IConvertible)fill).ToInt64(CultureInfo.InvariantCulture)));
+	            case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count, ((IConvertible)fill).ToSingle(CultureInfo.InvariantCulture)));
+	            case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count, ((IConvertible)fill).ToDouble(CultureInfo.InvariantCulture)));
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -330,27 +294,21 @@ public static IArraySlice Allocate(Type elementType, int count, bool fillDefault
 
             switch (elementType.GetTypeCode())
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return new ArraySlice<#2>(new UnmanagedMemoryBlock<#2>(count, default));
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count, default));
-                case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count, default));
-                case NPTypeCode.Int16: return new ArraySlice<short>(new UnmanagedMemoryBlock<short>(count, default));
-                case NPTypeCode.UInt16: return new ArraySlice<ushort>(new UnmanagedMemoryBlock<ushort>(count, default));
-                case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count, default));
-                case NPTypeCode.UInt32: return new ArraySlice<uint>(new UnmanagedMemoryBlock<uint>(count, default));
-                case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count, default));
-                case NPTypeCode.UInt64: return new ArraySlice<ulong>(new UnmanagedMemoryBlock<ulong>(count, default));
-                case NPTypeCode.Char: return new ArraySlice<char>(new UnmanagedMemoryBlock<char>(count, default));
-                case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count, default));
-                case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count, default));
-                case NPTypeCode.Decimal: return new ArraySlice<decimal>(new UnmanagedMemoryBlock<decimal>(count, default));
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count, default));
+	            case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count, default));
+	            case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count, default));
+	            case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count, default));
+	            case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count, default));
+	            case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count, default));
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -359,27 +317,21 @@ public static IArraySlice Allocate(Type elementType, int count)
         {
             switch (elementType.GetTypeCode())
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return new ArraySlice<#2>(new UnmanagedMemoryBlock<#2>(count));
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count));
-                case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count));
-                case NPTypeCode.Int16: return new ArraySlice<short>(new UnmanagedMemoryBlock<short>(count));
-                case NPTypeCode.UInt16: return new ArraySlice<ushort>(new UnmanagedMemoryBlock<ushort>(count));
-                case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count));
-                case NPTypeCode.UInt32: return new ArraySlice<uint>(new UnmanagedMemoryBlock<uint>(count));
-                case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count));
-                case NPTypeCode.UInt64: return new ArraySlice<ulong>(new UnmanagedMemoryBlock<ulong>(count));
-                case NPTypeCode.Char: return new ArraySlice<char>(new UnmanagedMemoryBlock<char>(count));
-                case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count));
-                case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count));
-                case NPTypeCode.Decimal: return new ArraySlice<decimal>(new UnmanagedMemoryBlock<decimal>(count));
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count));
+	            case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count));
+	            case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count));
+	            case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count));
+	            case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count));
+	            case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count));
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -388,27 +340,21 @@ public static IArraySlice Allocate(NPTypeCode typeCode, int count, object fill)
         {
             switch (typeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return new ArraySlice<#2>(new UnmanagedMemoryBlock<#2>(count, ((IConvertible)fill).To#1(CultureInfo.InvariantCulture)));
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count, ((IConvertible)fill).ToBoolean(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count, ((IConvertible)fill).ToByte(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Int16: return new ArraySlice<short>(new UnmanagedMemoryBlock<short>(count, ((IConvertible)fill).ToInt16(CultureInfo.InvariantCulture)));
-                case NPTypeCode.UInt16: return new ArraySlice<ushort>(new UnmanagedMemoryBlock<ushort>(count, ((IConvertible)fill).ToUInt16(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count, ((IConvertible)fill).ToInt32(CultureInfo.InvariantCulture)));
-                case NPTypeCode.UInt32: return new ArraySlice<uint>(new UnmanagedMemoryBlock<uint>(count, ((IConvertible)fill).ToUInt32(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count, ((IConvertible)fill).ToInt64(CultureInfo.InvariantCulture)));
-                case NPTypeCode.UInt64: return new ArraySlice<ulong>(new UnmanagedMemoryBlock<ulong>(count, ((IConvertible)fill).ToUInt64(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Char: return new ArraySlice<char>(new UnmanagedMemoryBlock<char>(count, ((IConvertible)fill).ToChar(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count, ((IConvertible)fill).ToDouble(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count, ((IConvertible)fill).ToSingle(CultureInfo.InvariantCulture)));
-                case NPTypeCode.Decimal: return new ArraySlice<decimal>(new UnmanagedMemoryBlock<decimal>(count, ((IConvertible)fill).ToDecimal(CultureInfo.InvariantCulture)));
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count, ((IConvertible)fill).ToBoolean(CultureInfo.InvariantCulture)));
+	            case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count, ((IConvertible)fill).ToByte(CultureInfo.InvariantCulture)));
+	            case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count, ((IConvertible)fill).ToInt32(CultureInfo.InvariantCulture)));
+	            case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count, ((IConvertible)fill).ToInt64(CultureInfo.InvariantCulture)));
+	            case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count, ((IConvertible)fill).ToSingle(CultureInfo.InvariantCulture)));
+	            case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count, ((IConvertible)fill).ToDouble(CultureInfo.InvariantCulture)));
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -420,27 +366,21 @@ public static IArraySlice Allocate(NPTypeCode typeCode, int count, bool fillDefa
 
             switch (typeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return new ArraySlice<#2>(new UnmanagedMemoryBlock<#2>(count, default));
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count, default));
-                case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count, default));
-                case NPTypeCode.Int16: return new ArraySlice<short>(new UnmanagedMemoryBlock<short>(count, default));
-                case NPTypeCode.UInt16: return new ArraySlice<ushort>(new UnmanagedMemoryBlock<ushort>(count, default));
-                case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count, default));
-                case NPTypeCode.UInt32: return new ArraySlice<uint>(new UnmanagedMemoryBlock<uint>(count, default));
-                case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count, default));
-                case NPTypeCode.UInt64: return new ArraySlice<ulong>(new UnmanagedMemoryBlock<ulong>(count, default));
-                case NPTypeCode.Char: return new ArraySlice<char>(new UnmanagedMemoryBlock<char>(count, default));
-                case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count, default));
-                case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count, default));
-                case NPTypeCode.Decimal: return new ArraySlice<decimal>(new UnmanagedMemoryBlock<decimal>(count, default));
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count, default));
+	            case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count, default));
+	            case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count, default));
+	            case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count, default));
+	            case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count, default));
+	            case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count, default));
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -449,27 +389,21 @@ public static IArraySlice Allocate(NPTypeCode typeCode, int count)
         {
             switch (typeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return new ArraySlice<#2>(new UnmanagedMemoryBlock<#2>(count));
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count));
-                case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count));
-                case NPTypeCode.Int16: return new ArraySlice<short>(new UnmanagedMemoryBlock<short>(count));
-                case NPTypeCode.UInt16: return new ArraySlice<ushort>(new UnmanagedMemoryBlock<ushort>(count));
-                case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count));
-                case NPTypeCode.UInt32: return new ArraySlice<uint>(new UnmanagedMemoryBlock<uint>(count));
-                case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count));
-                case NPTypeCode.UInt64: return new ArraySlice<ulong>(new UnmanagedMemoryBlock<ulong>(count));
-                case NPTypeCode.Char: return new ArraySlice<char>(new UnmanagedMemoryBlock<char>(count));
-                case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count));
-                case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count));
-                case NPTypeCode.Decimal: return new ArraySlice<decimal>(new UnmanagedMemoryBlock<decimal>(count));
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return new ArraySlice<bool>(new UnmanagedMemoryBlock<bool>(count));
+	            case NPTypeCode.Byte: return new ArraySlice<byte>(new UnmanagedMemoryBlock<byte>(count));
+	            case NPTypeCode.Int32: return new ArraySlice<int>(new UnmanagedMemoryBlock<int>(count));
+	            case NPTypeCode.Int64: return new ArraySlice<long>(new UnmanagedMemoryBlock<long>(count));
+	            case NPTypeCode.Single: return new ArraySlice<float>(new UnmanagedMemoryBlock<float>(count));
+	            case NPTypeCode.Double: return new ArraySlice<double>(new UnmanagedMemoryBlock<double>(count));
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
diff --git a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock.Casting.cs b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock.Casting.cs
index 1d021c46e..c3518934c 100644
--- a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock.Casting.cs
+++ b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock.Casting.cs
@@ -19,40 +19,21 @@ public static IMemoryBlock CastTo(this IMemoryBlock source, NPTypeCode to)
         {
             switch (to)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
-	            case NPTypeCode.#1:
-	                return Cast<#2>(source);
+	            case NPTypeCode.#1: return CastTo<#2>(source);
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean:
-                    return CastTo<bool>(source);
-                case NPTypeCode.Byte:
-                    return CastTo<byte>(source);
-                case NPTypeCode.Int16:
-                    return CastTo<short>(source);
-                case NPTypeCode.UInt16:
-                    return CastTo<ushort>(source);
-                case NPTypeCode.Int32:
-                    return CastTo<int>(source);
-                case NPTypeCode.UInt32:
-                    return CastTo<uint>(source);
-                case NPTypeCode.Int64:
-                    return CastTo<long>(source);
-                case NPTypeCode.UInt64:
-                    return CastTo<ulong>(source);
-                case NPTypeCode.Char:
-                    return CastTo<char>(source);
-                case NPTypeCode.Double:
-                    return CastTo<double>(source);
-                case NPTypeCode.Single:
-                    return CastTo<float>(source);
-                case NPTypeCode.Decimal:
-                    return CastTo<decimal>(source);
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return CastTo<bool>(source);
+	            case NPTypeCode.Byte: return CastTo<byte>(source);
+	            case NPTypeCode.Int32: return CastTo<int>(source);
+	            case NPTypeCode.Int64: return CastTo<long>(source);
+	            case NPTypeCode.Single: return CastTo<float>(source);
+	            case NPTypeCode.Double: return CastTo<double>(source);
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -70,25 +51,19 @@ public static IMemoryBlock<TOut> CastTo<TOut>(this IMemoryBlock source) where TO
             {
 #if _REGEN
 	                %foreach supported_dtypes,supported_dtypes_lowercase%
-	                case NPTypeCode.#1: return Cast<#2, TOut>(source);
+	                case NPTypeCode.#1: return CastTo<#2, TOut>(source);
 	                %
 	                default:
 		                throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return CastTo<bool, TOut>(source);
-                case NPTypeCode.Byte: return CastTo<byte, TOut>(source);
-                case NPTypeCode.Int16: return CastTo<short, TOut>(source);
-                case NPTypeCode.UInt16: return CastTo<ushort, TOut>(source);
-                case NPTypeCode.Int32: return CastTo<int, TOut>(source);
-                case NPTypeCode.UInt32: return CastTo<uint, TOut>(source);
-                case NPTypeCode.Int64: return CastTo<long, TOut>(source);
-                case NPTypeCode.UInt64: return CastTo<ulong, TOut>(source);
-                case NPTypeCode.Char: return CastTo<char, TOut>(source);
-                case NPTypeCode.Double: return CastTo<double, TOut>(source);
-                case NPTypeCode.Single: return CastTo<float, TOut>(source);
-                case NPTypeCode.Decimal: return CastTo<decimal, TOut>(source);
-                default:
-                    throw new NotSupportedException();
+	                case NPTypeCode.Boolean: return CastTo<bool, TOut>(source);
+	                case NPTypeCode.Byte: return CastTo<byte, TOut>(source);
+	                case NPTypeCode.Int32: return CastTo<int, TOut>(source);
+	                case NPTypeCode.Int64: return CastTo<long, TOut>(source);
+	                case NPTypeCode.Single: return CastTo<float, TOut>(source);
+	                case NPTypeCode.Double: return CastTo<double, TOut>(source);
+	                default:
+		                throw new NotSupportedException();
 #endif
             }
         }
@@ -180,54 +155,18 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 var dst = (byte*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int32:
                             {
                                 var dst = (int*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int64:
                             {
                                 var dst = (long*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Single:
                             {
@@ -235,10 +174,10 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                                 break;
                             }
-	                        case NPTypeCode.Decimal:
+	                        case NPTypeCode.Double:
                             {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                                var dst = (double*)ret.Address;
+                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                                 break;
                             }
 	                        default:
@@ -263,149 +202,30 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 var dst = (byte*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int32:
                             {
                                 var dst = (int*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int64:
                             {
                                 var dst = (long*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Single:
                             {
                                 var dst = (float*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.Decimal:
-                            {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                                break;
-                            }
-	                        default:
-		                        throw new NotSupportedException();
-                        }
-
-                        break;
-                    }
-	                case NPTypeCode.Int16:
-                    {
-                        var src = (short*)source.Address;
-                        switch (InfoOf<TOut>.NPTypeCode)
-                        {
-	                        case NPTypeCode.Boolean:
-                            {
-                                var dst = (bool*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Byte:
-                            {
-                                var dst = (byte*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int32:
-                            {
-                                var dst = (int*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int64:
-                            {
-                                var dst = (long*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Double:
                             {
                                 var dst = (double*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.Single:
-                            {
-                                var dst = (float*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Decimal:
-                            {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                                break;
                             }
 	                        default:
 		                        throw new NotSupportedException();
@@ -413,9 +233,9 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
 
                         break;
                     }
-	                case NPTypeCode.UInt16:
+	                case NPTypeCode.Int32:
                     {
-                        var src = (ushort*)source.Address;
+                        var src = (int*)source.Address;
                         switch (InfoOf<TOut>.NPTypeCode)
                         {
 	                        case NPTypeCode.Boolean:
@@ -429,54 +249,18 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 var dst = (byte*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int32:
                             {
                                 var dst = (int*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int64:
                             {
                                 var dst = (long*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Single:
                             {
@@ -484,10 +268,10 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                                 break;
                             }
-	                        case NPTypeCode.Decimal:
+	                        case NPTypeCode.Double:
                             {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                                var dst = (double*)ret.Address;
+                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                                 break;
                             }
 	                        default:
@@ -496,9 +280,9 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
 
                         break;
                     }
-	                case NPTypeCode.Int32:
+	                case NPTypeCode.Int64:
                     {
-                        var src = (int*)source.Address;
+                        var src = (long*)source.Address;
                         switch (InfoOf<TOut>.NPTypeCode)
                         {
 	                        case NPTypeCode.Boolean:
@@ -512,54 +296,18 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 var dst = (byte*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int32:
                             {
                                 var dst = (int*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int64:
                             {
                                 var dst = (long*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Single:
                             {
@@ -567,10 +315,10 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                                 break;
                             }
-	                        case NPTypeCode.Decimal:
+	                        case NPTypeCode.Double:
                             {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                                var dst = (double*)ret.Address;
+                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                                 break;
                             }
 	                        default:
@@ -579,9 +327,9 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
 
                         break;
                     }
-	                case NPTypeCode.UInt32:
+	                case NPTypeCode.Single:
                     {
-                        var src = (uint*)source.Address;
+                        var src = (float*)source.Address;
                         switch (InfoOf<TOut>.NPTypeCode)
                         {
 	                        case NPTypeCode.Boolean:
@@ -595,54 +343,18 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 var dst = (byte*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int32:
                             {
                                 var dst = (int*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int64:
                             {
                                 var dst = (long*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Single:
                             {
@@ -650,10 +362,10 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                                 break;
                             }
-	                        case NPTypeCode.Decimal:
+	                        case NPTypeCode.Double:
                             {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                                var dst = (double*)ret.Address;
+                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                                 break;
                             }
 	                        default:
@@ -662,9 +374,9 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
 
                         break;
                     }
-	                case NPTypeCode.Int64:
+	                case NPTypeCode.Double:
                     {
-                        var src = (long*)source.Address;
+                        var src = (double*)source.Address;
                         switch (InfoOf<TOut>.NPTypeCode)
                         {
 	                        case NPTypeCode.Boolean:
@@ -678,54 +390,18 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 var dst = (byte*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int32:
                             {
                                 var dst = (int*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Int64:
                             {
                                 var dst = (long*)ret.Address;
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                                 break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
                             }
 	                        case NPTypeCode.Single:
                             {
@@ -733,10 +409,10 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
                                 Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                                 break;
                             }
-	                        case NPTypeCode.Decimal:
+	                        case NPTypeCode.Double:
                             {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                                var dst = (double*)ret.Address;
+                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                                 break;
                             }
 	                        default:
@@ -745,984 +421,71 @@ public static IMemoryBlock<TOut> CastTo<TIn, TOut>(this IMemoryBlock source) whe
 
                         break;
                     }
-	                case NPTypeCode.UInt64:
-                    {
-                        var src = (ulong*)source.Address;
-                        switch (InfoOf<TOut>.NPTypeCode)
-                        {
-	                        case NPTypeCode.Boolean:
-                            {
-                                var dst = (bool*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Byte:
-                            {
-                                var dst = (byte*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int32:
-                            {
-                                var dst = (int*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int64:
-                            {
-                                var dst = (long*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Single:
-                            {
-                                var dst = (float*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Decimal:
-                            {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                                break;
-                            }
-	                        default:
-		                        throw new NotSupportedException();
-                        }
-
-                        break;
-                    }
-	                case NPTypeCode.Char:
-                    {
-                        var src = (char*)source.Address;
-                        switch (InfoOf<TOut>.NPTypeCode)
-                        {
-	                        case NPTypeCode.Boolean:
-                            {
-                                var dst = (bool*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Byte:
-                            {
-                                var dst = (byte*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int32:
-                            {
-                                var dst = (int*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int64:
-                            {
-                                var dst = (long*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Single:
-                            {
-                                var dst = (float*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Decimal:
-                            {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                                break;
-                            }
-	                        default:
-		                        throw new NotSupportedException();
-                        }
-
-                        break;
-                    }
-	                case NPTypeCode.Double:
-                    {
-                        var src = (double*)source.Address;
-                        switch (InfoOf<TOut>.NPTypeCode)
-                        {
-	                        case NPTypeCode.Boolean:
-                            {
-                                var dst = (bool*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Byte:
-                            {
-                                var dst = (byte*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int32:
-                            {
-                                var dst = (int*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int64:
-                            {
-                                var dst = (long*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Single:
-                            {
-                                var dst = (float*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Decimal:
-                            {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                                break;
-                            }
-	                        default:
-		                        throw new NotSupportedException();
-                        }
-
-                        break;
-                    }
-	                case NPTypeCode.Single:
-                    {
-                        var src = (float*)source.Address;
-                        switch (InfoOf<TOut>.NPTypeCode)
-                        {
-	                        case NPTypeCode.Boolean:
-                            {
-                                var dst = (bool*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Byte:
-                            {
-                                var dst = (byte*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int32:
-                            {
-                                var dst = (int*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int64:
-                            {
-                                var dst = (long*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Single:
-                            {
-                                var dst = (float*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Decimal:
-                            {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                                break;
-                            }
-	                        default:
-		                        throw new NotSupportedException();
-                        }
-
-                        break;
-                    }
-	                case NPTypeCode.Decimal:
-                    {
-                        var src = (decimal*)source.Address;
-                        switch (InfoOf<TOut>.NPTypeCode)
-                        {
-	                        case NPTypeCode.Boolean:
-                            {
-                                var dst = (bool*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Byte:
-                            {
-                                var dst = (byte*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int16:
-                            {
-                                var dst = (short*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt16:
-                            {
-                                var dst = (ushort*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int32:
-                            {
-                                var dst = (int*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt32:
-                            {
-                                var dst = (uint*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Int64:
-                            {
-                                var dst = (long*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.UInt64:
-                            {
-                                var dst = (ulong*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Char:
-                            {
-                                var dst = (char*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Double:
-                            {
-                                var dst = (double*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Single:
-                            {
-                                var dst = (float*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                                break;
-                            }
-	                        case NPTypeCode.Decimal:
-                            {
-                                var dst = (decimal*)ret.Address;
-                                Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                                break;
-                            }
-	                        default:
-		                        throw new NotSupportedException();
-                        }
-
-                        break;
-                    }
-	                default:
-		                throw new NotSupportedException();
-                    #endregion
-#endif
-                }
-
-                if (source is IArraySlice)
-                    return new ArraySlice<TOut>(ret);
-
-                return ret;
-            }
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="source"></param>
-        /// <param name="out"></param>
-        /// <returns></returns>
-        /// <remarks>Returns a copy.</remarks>
-        [MethodImpl((MethodImplOptions)768)]
-        public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, int? bytesOffset = null, int? countOffset = null)
-        {
-            var len = source.Count;
-            var offset = countOffset ?? ((bytesOffset ?? 0) / @out.ItemLength);
-            var ret = @out ?? throw new ArgumentNullException(nameof(@out));
-            if (source.BytesLength + bytesOffset > ret.BytesLength)
-                throw new ArgumentOutOfRangeException(nameof(@out), "The length of IMemoryBlock @out does not match source's length.");
-
-            switch (source.TypeCode)
-            {
-
-#if _REGEN
-                #region Compute
-                //#n is in, #10n is out
-	            %foreach supported_dtypes,supported_dtypes_lowercase%
-	            case NPTypeCode.#1:
-                {
-                    var src = (#2*)source.Address;
-                    switch (ret.TypeCode)
-                    {
-	                    %foreach supported_dtypes,supported_dtypes_lowercase%
-	                    case NPTypeCode.#101:
-                        {
-                            var dst = (#102*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.To#101(*(src + i)));
-                            break;
-                        }
-	                    %
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-	            %
-	            default:
-		            throw new NotSupportedException();
-                #endregion
-#else
-                #region Compute
-                //#n is in, #10n is out
-	            case NPTypeCode.Boolean:
-                {
-                    var src = (bool*)source.Address;
-                    switch (ret.TypeCode)
-                    {
-	                    case NPTypeCode.Boolean:
-                        {
-                            var dst = (bool*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Byte:
-                        {
-                            var dst = (byte*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int32:
-                        {
-                            var dst = (int*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int64:
-                        {
-                            var dst = (long*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Single:
-                        {
-                            var dst = (float*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Decimal:
-                        {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                            break;
-                        }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-	            case NPTypeCode.Byte:
-                {
-                    var src = (byte*)source.Address;
-                    switch (ret.TypeCode)
-                    {
-	                    case NPTypeCode.Boolean:
-                        {
-                            var dst = (bool*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Byte:
-                        {
-                            var dst = (byte*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int32:
-                        {
-                            var dst = (int*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int64:
-                        {
-                            var dst = (long*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Single:
-                        {
-                            var dst = (float*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Decimal:
-                        {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                            break;
-                        }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-	            case NPTypeCode.Int16:
-                {
-                    var src = (short*)source.Address;
-                    switch (ret.TypeCode)
-                    {
-	                    case NPTypeCode.Boolean:
-                        {
-                            var dst = (bool*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Byte:
-                        {
-                            var dst = (byte*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int32:
-                        {
-                            var dst = (int*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int64:
-                        {
-                            var dst = (long*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Single:
-                        {
-                            var dst = (float*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Decimal:
-                        {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                            break;
-                        }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-	            case NPTypeCode.UInt16:
-                {
-                    var src = (ushort*)source.Address;
-                    switch (ret.TypeCode)
-                    {
-	                    case NPTypeCode.Boolean:
-                        {
-                            var dst = (bool*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Byte:
-                        {
-                            var dst = (byte*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int32:
-                        {
-                            var dst = (int*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int64:
-                        {
-                            var dst = (long*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Single:
-                        {
-                            var dst = (float*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Decimal:
-                        {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                            break;
-                        }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-
-                    break;
-                }
-	            case NPTypeCode.Int32:
-                {
-                    var src = (int*)source.Address;
-                    switch (ret.TypeCode)
-                    {
-	                    case NPTypeCode.Boolean:
-                        {
-                            var dst = (bool*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Byte:
-                        {
-                            var dst = (byte*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int32:
-                        {
-                            var dst = (int*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int64:
-                        {
-                            var dst = (long*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Single:
-                        {
-                            var dst = (float*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Decimal:
-                        {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
-                            break;
-                        }
-	                    default:
-		                    throw new NotSupportedException();
-                    }
-
-                    break;
+	                default:
+		                throw new NotSupportedException();
+                    #endregion
+#endif
                 }
-	            case NPTypeCode.UInt32:
+
+                if (source is IArraySlice)
+                    return new ArraySlice<TOut>(ret);
+
+                return ret;
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="source"></param>
+        /// <param name="out"></param>
+        /// <returns></returns>
+        /// <remarks>Returns a copy.</remarks>
+        [MethodImpl((MethodImplOptions)768)]
+        public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, int? bytesOffset = null, int? countOffset = null)
+        {
+            var len = source.Count;
+            var offset = countOffset ?? ((bytesOffset ?? 0) / @out.ItemLength);
+            var ret = @out ?? throw new ArgumentNullException(nameof(@out));
+            if (source.BytesLength + bytesOffset > ret.BytesLength)
+                throw new ArgumentOutOfRangeException(nameof(@out), "The length of IMemoryBlock @out does not match source's length.");
+
+            switch (source.TypeCode)
+            {
+
+#if _REGEN
+                #region Compute
+                //#n is in, #10n is out
+	            %foreach supported_dtypes,supported_dtypes_lowercase%
+	            case NPTypeCode.#1:
                 {
-                    var src = (uint*)source.Address;
+                    var src = (#2*)source.Address;
                     switch (ret.TypeCode)
                     {
-	                    case NPTypeCode.Boolean:
-                        {
-                            var dst = (bool*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToBoolean(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Byte:
-                        {
-                            var dst = (byte*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int32:
-                        {
-                            var dst = (int*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Int64:
-                        {
-                            var dst = (long*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Single:
-                        {
-                            var dst = (float*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Decimal:
+	                    %foreach supported_dtypes,supported_dtypes_lowercase%
+	                    case NPTypeCode.#101:
                         {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                            var dst = (#102*)ret.Address + offset;
+                            Parallel.For(0, len, i => *(dst + i) = Converts.To#101(*(src + i)));
                             break;
                         }
+	                    %
 	                    default:
 		                    throw new NotSupportedException();
                     }
 
                     break;
                 }
-	            case NPTypeCode.Int64:
+	            %
+	            default:
+		            throw new NotSupportedException();
+                #endregion
+#else
+                #region Compute
+                //#n is in, #10n is out
+	            case NPTypeCode.Boolean:
                 {
-                    var src = (long*)source.Address;
+                    var src = (bool*)source.Address;
                     switch (ret.TypeCode)
                     {
 	                    case NPTypeCode.Boolean:
@@ -1736,54 +499,18 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             var dst = (byte*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int32:
                         {
                             var dst = (int*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int64:
                         {
                             var dst = (long*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Single:
                         {
@@ -1791,10 +518,10 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                             break;
                         }
-	                    case NPTypeCode.Decimal:
+	                    case NPTypeCode.Double:
                         {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                            var dst = (double*)ret.Address + offset;
+                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                             break;
                         }
 	                    default:
@@ -1803,9 +530,9 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
 
                     break;
                 }
-	            case NPTypeCode.UInt64:
+	            case NPTypeCode.Byte:
                 {
-                    var src = (ulong*)source.Address;
+                    var src = (byte*)source.Address;
                     switch (ret.TypeCode)
                     {
 	                    case NPTypeCode.Boolean:
@@ -1819,54 +546,18 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             var dst = (byte*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int32:
                         {
                             var dst = (int*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int64:
                         {
                             var dst = (long*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Single:
                         {
@@ -1874,10 +565,10 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                             break;
                         }
-	                    case NPTypeCode.Decimal:
+	                    case NPTypeCode.Double:
                         {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                            var dst = (double*)ret.Address + offset;
+                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                             break;
                         }
 	                    default:
@@ -1886,9 +577,9 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
 
                     break;
                 }
-	            case NPTypeCode.Char:
+	            case NPTypeCode.Int32:
                 {
-                    var src = (char*)source.Address;
+                    var src = (int*)source.Address;
                     switch (ret.TypeCode)
                     {
 	                    case NPTypeCode.Boolean:
@@ -1902,54 +593,18 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             var dst = (byte*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int32:
                         {
                             var dst = (int*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int64:
                         {
                             var dst = (long*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Single:
                         {
@@ -1957,10 +612,10 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                             break;
                         }
-	                    case NPTypeCode.Decimal:
+	                    case NPTypeCode.Double:
                         {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                            var dst = (double*)ret.Address + offset;
+                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                             break;
                         }
 	                    default:
@@ -1969,9 +624,9 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
 
                     break;
                 }
-	            case NPTypeCode.Double:
+	            case NPTypeCode.Int64:
                 {
-                    var src = (double*)source.Address;
+                    var src = (long*)source.Address;
                     switch (ret.TypeCode)
                     {
 	                    case NPTypeCode.Boolean:
@@ -1985,54 +640,18 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             var dst = (byte*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int32:
                         {
                             var dst = (int*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int64:
                         {
                             var dst = (long*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Single:
                         {
@@ -2040,10 +659,10 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                             break;
                         }
-	                    case NPTypeCode.Decimal:
+	                    case NPTypeCode.Double:
                         {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                            var dst = (double*)ret.Address + offset;
+                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                             break;
                         }
 	                    default:
@@ -2068,54 +687,18 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             var dst = (byte*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int32:
                         {
                             var dst = (int*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int64:
                         {
                             var dst = (long*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Single:
                         {
@@ -2123,10 +706,10 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                             break;
                         }
-	                    case NPTypeCode.Decimal:
+	                    case NPTypeCode.Double:
                         {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                            var dst = (double*)ret.Address + offset;
+                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                             break;
                         }
 	                    default:
@@ -2135,9 +718,9 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
 
                     break;
                 }
-	            case NPTypeCode.Decimal:
+	            case NPTypeCode.Double:
                 {
-                    var src = (decimal*)source.Address;
+                    var src = (double*)source.Address;
                     switch (ret.TypeCode)
                     {
 	                    case NPTypeCode.Boolean:
@@ -2151,54 +734,18 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             var dst = (byte*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToByte(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.Int16:
-                        {
-                            var dst = (short*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToInt16(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.UInt16:
-                        {
-                            var dst = (ushort*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt16(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int32:
                         {
                             var dst = (int*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt32(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt32:
-                        {
-                            var dst = (uint*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt32(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Int64:
                         {
                             var dst = (long*)ret.Address + offset;
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToInt64(*(src + i)));
                             break;
-                        }
-	                    case NPTypeCode.UInt64:
-                        {
-                            var dst = (ulong*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToUInt64(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Char:
-                        {
-                            var dst = (char*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToChar(*(src + i)));
-                            break;
-                        }
-	                    case NPTypeCode.Double:
-                        {
-                            var dst = (double*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
-                            break;
                         }
 	                    case NPTypeCode.Single:
                         {
@@ -2206,10 +753,10 @@ public static unsafe void CastTo(this IMemoryBlock source, IMemoryBlock @out, in
                             Parallel.For(0, len, i => *(dst + i) = Converts.ToSingle(*(src + i)));
                             break;
                         }
-	                    case NPTypeCode.Decimal:
+	                    case NPTypeCode.Double:
                         {
-                            var dst = (decimal*)ret.Address + offset;
-                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDecimal(*(src + i)));
+                            var dst = (double*)ret.Address + offset;
+                            Parallel.For(0, len, i => *(dst + i) = Converts.ToDouble(*(src + i)));
                             break;
                         }
 	                    default:
diff --git a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock.cs b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock.cs
index e6ae63f03..3e84fb0e2 100644
--- a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock.cs
+++ b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock.cs
@@ -17,7 +17,7 @@ public static IMemoryBlock FromArray(Array arr, bool copy, Type elementType = nu
 
             switch (elementType.GetTypeCode())
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1:
                     return UnmanagedMemoryBlock<#2>.FromArray((#2[])arr);
@@ -29,26 +29,14 @@ public static IMemoryBlock FromArray(Array arr, bool copy, Type elementType = nu
                     return UnmanagedMemoryBlock<bool>.FromArray((bool[])arr);
 	            case NPTypeCode.Byte:
                     return UnmanagedMemoryBlock<byte>.FromArray((byte[])arr);
-	            case NPTypeCode.Int16:
-                    return UnmanagedMemoryBlock<short>.FromArray((short[])arr);
-	            case NPTypeCode.UInt16:
-                    return UnmanagedMemoryBlock<ushort>.FromArray((ushort[])arr);
 	            case NPTypeCode.Int32:
                     return UnmanagedMemoryBlock<int>.FromArray((int[])arr);
-	            case NPTypeCode.UInt32:
-                    return UnmanagedMemoryBlock<uint>.FromArray((uint[])arr);
 	            case NPTypeCode.Int64:
                     return UnmanagedMemoryBlock<long>.FromArray((long[])arr);
-	            case NPTypeCode.UInt64:
-                    return UnmanagedMemoryBlock<ulong>.FromArray((ulong[])arr);
-	            case NPTypeCode.Char:
-                    return UnmanagedMemoryBlock<char>.FromArray((char[])arr);
-	            case NPTypeCode.Double:
-                    return UnmanagedMemoryBlock<double>.FromArray((double[])arr);
 	            case NPTypeCode.Single:
                     return UnmanagedMemoryBlock<float>.FromArray((float[])arr);
-	            case NPTypeCode.Decimal:
-                    return UnmanagedMemoryBlock<decimal>.FromArray((decimal[])arr);
+	            case NPTypeCode.Double:
+                    return UnmanagedMemoryBlock<double>.FromArray((double[])arr);
 	            default:
 		            throw new NotSupportedException();
 #endif
@@ -59,7 +47,7 @@ public static IMemoryBlock Allocate(Type elementType, int count)
         {
             switch (elementType.GetTypeCode())
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1:
                     return new UnmanagedMemoryBlock<#2>(count);
@@ -67,30 +55,20 @@ public static IMemoryBlock Allocate(Type elementType, int count)
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Byte:
+	            case NPTypeCode.Boolean:
+                    return new UnmanagedMemoryBlock<bool>(count);
+	            case NPTypeCode.Byte:
                     return new UnmanagedMemoryBlock<byte>(count);
-                case NPTypeCode.Int16:
-                    return new UnmanagedMemoryBlock<short>(count);
-                case NPTypeCode.UInt16:
-                    return new UnmanagedMemoryBlock<ushort>(count);
-                case NPTypeCode.Int32:
+	            case NPTypeCode.Int32:
                     return new UnmanagedMemoryBlock<int>(count);
-                case NPTypeCode.UInt32:
-                    return new UnmanagedMemoryBlock<uint>(count);
-                case NPTypeCode.Int64:
+	            case NPTypeCode.Int64:
                     return new UnmanagedMemoryBlock<long>(count);
-                case NPTypeCode.UInt64:
-                    return new UnmanagedMemoryBlock<ulong>(count);
-                case NPTypeCode.Char:
-                    return new UnmanagedMemoryBlock<char>(count);
-                case NPTypeCode.Double:
-                    return new UnmanagedMemoryBlock<double>(count);
-                case NPTypeCode.Single:
+	            case NPTypeCode.Single:
                     return new UnmanagedMemoryBlock<float>(count);
-                case NPTypeCode.Decimal:
-                    return new UnmanagedMemoryBlock<decimal>(count);
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Double:
+                    return new UnmanagedMemoryBlock<double>(count);
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
@@ -99,7 +77,7 @@ public static IMemoryBlock Allocate(Type elementType, int count, object fill)
         {
             switch (elementType.GetTypeCode())
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1:
                     return new UnmanagedMemoryBlock<#2>(count, (#2)fill);
@@ -107,30 +85,20 @@ public static IMemoryBlock Allocate(Type elementType, int count, object fill)
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Byte:
+	            case NPTypeCode.Boolean:
+                    return new UnmanagedMemoryBlock<bool>(count, (bool)fill);
+	            case NPTypeCode.Byte:
                     return new UnmanagedMemoryBlock<byte>(count, (byte)fill);
-                case NPTypeCode.Int16:
-                    return new UnmanagedMemoryBlock<short>(count, (short)fill);
-                case NPTypeCode.UInt16:
-                    return new UnmanagedMemoryBlock<ushort>(count, (ushort)fill);
-                case NPTypeCode.Int32:
+	            case NPTypeCode.Int32:
                     return new UnmanagedMemoryBlock<int>(count, (int)fill);
-                case NPTypeCode.UInt32:
-                    return new UnmanagedMemoryBlock<uint>(count, (uint)fill);
-                case NPTypeCode.Int64:
+	            case NPTypeCode.Int64:
                     return new UnmanagedMemoryBlock<long>(count, (long)fill);
-                case NPTypeCode.UInt64:
-                    return new UnmanagedMemoryBlock<ulong>(count, (ulong)fill);
-                case NPTypeCode.Char:
-                    return new UnmanagedMemoryBlock<char>(count, (char)fill);
-                case NPTypeCode.Double:
-                    return new UnmanagedMemoryBlock<double>(count, (double)fill);
-                case NPTypeCode.Single:
+	            case NPTypeCode.Single:
                     return new UnmanagedMemoryBlock<float>(count, (float)fill);
-                case NPTypeCode.Decimal:
-                    return new UnmanagedMemoryBlock<decimal>(count, (decimal)fill);
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Double:
+                    return new UnmanagedMemoryBlock<double>(count, (double)fill);
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
diff --git a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.Getters.cs b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.Getters.cs
index eb568dcf4..b4d44f36c 100644
--- a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.Getters.cs
+++ b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.Getters.cs
@@ -19,34 +19,28 @@ public unsafe ValueType GetValue(params int[] indices)
         {
             switch (TypeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return *((#2*)Address + _shape.GetOffset(indices));
 	            %
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return *((bool*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.Byte: return *((byte*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.Int16: return *((short*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.UInt16: return *((ushort*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.Int32: return *((int*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.UInt32: return *((uint*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.Int64: return *((long*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.UInt64: return *((ulong*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.Char: return *((char*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.Double: return *((double*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.Single: return *((float*)Address + _shape.GetOffset(indices));
-                case NPTypeCode.Decimal: return *((decimal*)Address + _shape.GetOffset(indices));
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return *((bool*)Address + _shape.GetOffset(indices));
+	            case NPTypeCode.Byte: return *((byte*)Address + _shape.GetOffset(indices));
+	            case NPTypeCode.Int32: return *((int*)Address + _shape.GetOffset(indices));
+	            case NPTypeCode.Int64: return *((long*)Address + _shape.GetOffset(indices));
+	            case NPTypeCode.Single: return *((float*)Address + _shape.GetOffset(indices));
+	            case NPTypeCode.Double: return *((double*)Address + _shape.GetOffset(indices));
+	            default:
+		            throw new NotSupportedException();
 #endif
             }
         }
 
         public unsafe ValueType GetAtIndex(int index)
         {
-#if _REGEN
+#if _REGEN1
             switch (TypeCode)
             {
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
@@ -58,20 +52,14 @@ public unsafe ValueType GetAtIndex(int index)
 #else
             switch (TypeCode)
             {
-                case NPTypeCode.Boolean: return *((bool*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.Byte: return *((byte*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.Int16: return *((short*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.UInt16: return *((ushort*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.Int32: return *((int*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.UInt32: return *((uint*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.Int64: return *((long*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.UInt64: return *((ulong*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.Char: return *((char*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.Double: return *((double*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.Single: return *((float*)Address + _shape.TransformOffset(index));
-                case NPTypeCode.Decimal: return *((decimal*)Address + _shape.TransformOffset(index));
-                default:
-                    throw new NotSupportedException();
+	            case NPTypeCode.Boolean: return *((bool*)Address + _shape.TransformOffset(index));
+	            case NPTypeCode.Byte: return *((byte*)Address + _shape.TransformOffset(index));
+	            case NPTypeCode.Int32: return *((int*)Address + _shape.TransformOffset(index));
+	            case NPTypeCode.Int64: return *((long*)Address + _shape.TransformOffset(index));
+	            case NPTypeCode.Single: return *((float*)Address + _shape.TransformOffset(index));
+	            case NPTypeCode.Double: return *((double*)Address + _shape.TransformOffset(index));
+	            default:
+		            throw new NotSupportedException();
             }
 #endif
         }
@@ -188,7 +176,7 @@ public T GetValue<T>(params int[] indices) where T : unmanaged
         /// <returns>reference to internal storage as System.Array</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public IArraySlice GetData() => InternalArray;
-#if _REGEN
+#if _REGEN1
         #region Direct Getters
      
         %foreach supported_dtypes,supported_dtypes_lowercase%
@@ -225,24 +213,6 @@ public bool GetBoolean(params int[] indices)
         public byte GetByte(params int[] indices)
             => _arrayByte[_shape.GetOffset(indices)];
 
-        /// <summary>
-        ///     Retrieves value of type <see cref="short"/> from internal storage.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="short"/></exception>
-        public short GetInt16(params int[] indices)
-            => _arrayInt16[_shape.GetOffset(indices)];
-
-        /// <summary>
-        ///     Retrieves value of type <see cref="ushort"/> from internal storage.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="ushort"/></exception>
-        public ushort GetUInt16(params int[] indices)
-            => _arrayUInt16[_shape.GetOffset(indices)];
-
         /// <summary>
         ///     Retrieves value of type <see cref="int"/> from internal storage.
         /// </summary>
@@ -252,15 +222,6 @@ public ushort GetUInt16(params int[] indices)
         public int GetInt32(params int[] indices)
             => _arrayInt32[_shape.GetOffset(indices)];
 
-        /// <summary>
-        ///     Retrieves value of type <see cref="uint"/> from internal storage.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="uint"/></exception>
-        public uint GetUInt32(params int[] indices)
-            => _arrayUInt32[_shape.GetOffset(indices)];
-
         /// <summary>
         ///     Retrieves value of type <see cref="long"/> from internal storage.
         /// </summary>
@@ -270,33 +231,6 @@ public uint GetUInt32(params int[] indices)
         public long GetInt64(params int[] indices)
             => _arrayInt64[_shape.GetOffset(indices)];
 
-        /// <summary>
-        ///     Retrieves value of type <see cref="ulong"/> from internal storage.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="ulong"/></exception>
-        public ulong GetUInt64(params int[] indices)
-            => _arrayUInt64[_shape.GetOffset(indices)];
-
-        /// <summary>
-        ///     Retrieves value of type <see cref="char"/> from internal storage.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="char"/></exception>
-        public char GetChar(params int[] indices)
-            => _arrayChar[_shape.GetOffset(indices)];
-
-        /// <summary>
-        ///     Retrieves value of type <see cref="double"/> from internal storage.
-        /// </summary>
-        /// <param name="indices">The shape's indices to get.</param>
-        /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="double"/></exception>
-        public double GetDouble(params int[] indices)
-            => _arrayDouble[_shape.GetOffset(indices)];
-
         /// <summary>
         ///     Retrieves value of type <see cref="float"/> from internal storage.
         /// </summary>
@@ -307,13 +241,13 @@ public float GetSingle(params int[] indices)
             => _arraySingle[_shape.GetOffset(indices)];
 
         /// <summary>
-        ///     Retrieves value of type <see cref="decimal"/> from internal storage.
+        ///     Retrieves value of type <see cref="double"/> from internal storage.
         /// </summary>
         /// <param name="indices">The shape's indices to get.</param>
         /// <returns></returns>
-        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="decimal"/></exception>
-        public decimal GetDecimal(params int[] indices)
-            => _arrayDecimal[_shape.GetOffset(indices)];
+        /// <exception cref="NullReferenceException">When <see cref="DType"/> is not <see cref="double"/></exception>
+        public double GetDouble(params int[] indices)
+            => _arrayDouble[_shape.GetOffset(indices)];
 
         #endregion
 #endif
diff --git a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.Setters.cs b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.Setters.cs
index 5f316c741..67ac2770f 100644
--- a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.Setters.cs
+++ b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.Setters.cs
@@ -39,7 +39,7 @@ public unsafe void SetAtIndex(object value, int index)
         {
             switch (_typecode)
             {
-#if _REGEN
+#if _REGEN1
                 //Since it is a single assignment, we do not use 'as' casting but rather explicit casting that'll also type-check.
                 %foreach supported_dtypes,supported_dtypes_lowercase%
                 case NPTypeCode.#1:
@@ -52,40 +52,22 @@ public unsafe void SetAtIndex(object value, int index)
 
                 //Since it is a single assignment, we do not use 'as' casting but rather explicit casting that'll also type-check.
                 case NPTypeCode.Boolean:
-                    *((bool*)Address + _shape.TransformOffset(index)) = (bool)value;
+                    *((bool*)Address + _shape.TransformOffset(index)) = (bool) value;
                     return;
                 case NPTypeCode.Byte:
-                    *((byte*)Address + _shape.TransformOffset(index)) = (byte)value;
-                    return;
-                case NPTypeCode.Int16:
-                    *((short*)Address + _shape.TransformOffset(index)) = (short)value;
-                    return;
-                case NPTypeCode.UInt16:
-                    *((ushort*)Address + _shape.TransformOffset(index)) = (ushort)value;
+                    *((byte*)Address + _shape.TransformOffset(index)) = (byte) value;
                     return;
                 case NPTypeCode.Int32:
-                    *((int*)Address + _shape.TransformOffset(index)) = (int)value;
-                    return;
-                case NPTypeCode.UInt32:
-                    *((uint*)Address + _shape.TransformOffset(index)) = (uint)value;
+                    *((int*)Address + _shape.TransformOffset(index)) = (int) value;
                     return;
                 case NPTypeCode.Int64:
-                    *((long*)Address + _shape.TransformOffset(index)) = (long)value;
-                    return;
-                case NPTypeCode.UInt64:
-                    *((ulong*)Address + _shape.TransformOffset(index)) = (ulong)value;
-                    return;
-                case NPTypeCode.Char:
-                    *((char*)Address + _shape.TransformOffset(index)) = (char)value;
-                    return;
-                case NPTypeCode.Double:
-                    *((double*)Address + _shape.TransformOffset(index)) = (double)value;
+                    *((long*)Address + _shape.TransformOffset(index)) = (long) value;
                     return;
                 case NPTypeCode.Single:
-                    *((float*)Address + _shape.TransformOffset(index)) = (float)value;
+                    *((float*)Address + _shape.TransformOffset(index)) = (float) value;
                     return;
-                case NPTypeCode.Decimal:
-                    *((decimal*)Address + _shape.TransformOffset(index)) = (decimal)value;
+                case NPTypeCode.Double:
+                    *((double*)Address + _shape.TransformOffset(index)) = (double) value;
                     return;
                 default:
                     throw new NotSupportedException();
@@ -118,7 +100,7 @@ public unsafe void SetValue(object value, params int[] indices)
         {
             switch (_typecode)
             {
-#if _REGEN
+#if _REGEN1
                 //Since it is a single assignment, we do not use 'as' casting but rather explicit casting that'll also type-check.
                 %foreach supported_dtypes,supported_dtypes_lowercase%
                 case NPTypeCode.#1:
@@ -131,40 +113,22 @@ public unsafe void SetValue(object value, params int[] indices)
 
                 //Since it is a single assignment, we do not use 'as' casting but rather explicit casting that'll also type-check.
                 case NPTypeCode.Boolean:
-                    *((bool*)Address + _shape.GetOffset(indices)) = (bool)value;
+                    *((bool*)Address + _shape.GetOffset(indices)) = (bool) value;
                     return;
                 case NPTypeCode.Byte:
-                    *((byte*)Address + _shape.GetOffset(indices)) = (byte)value;
-                    return;
-                case NPTypeCode.Int16:
-                    *((short*)Address + _shape.GetOffset(indices)) = (short)value;
-                    return;
-                case NPTypeCode.UInt16:
-                    *((ushort*)Address + _shape.GetOffset(indices)) = (ushort)value;
+                    *((byte*)Address + _shape.GetOffset(indices)) = (byte) value;
                     return;
                 case NPTypeCode.Int32:
-                    *((int*)Address + _shape.GetOffset(indices)) = (int)value;
-                    return;
-                case NPTypeCode.UInt32:
-                    *((uint*)Address + _shape.GetOffset(indices)) = (uint)value;
+                    *((int*)Address + _shape.GetOffset(indices)) = (int) value;
                     return;
                 case NPTypeCode.Int64:
-                    *((long*)Address + _shape.GetOffset(indices)) = (long)value;
-                    return;
-                case NPTypeCode.UInt64:
-                    *((ulong*)Address + _shape.GetOffset(indices)) = (ulong)value;
-                    return;
-                case NPTypeCode.Char:
-                    *((char*)Address + _shape.GetOffset(indices)) = (char)value;
-                    return;
-                case NPTypeCode.Double:
-                    *((double*)Address + _shape.GetOffset(indices)) = (double)value;
+                    *((long*)Address + _shape.GetOffset(indices)) = (long) value;
                     return;
                 case NPTypeCode.Single:
-                    *((float*)Address + _shape.GetOffset(indices)) = (float)value;
+                    *((float*)Address + _shape.GetOffset(indices)) = (float) value;
                     return;
-                case NPTypeCode.Decimal:
-                    *((decimal*)Address + _shape.GetOffset(indices)) = (decimal)value;
+                case NPTypeCode.Double:
+                    *((double*)Address + _shape.GetOffset(indices)) = (double) value;
                     return;
                 default:
                     throw new NotSupportedException();
@@ -322,10 +286,9 @@ public void SetData(IArraySlice value, params int[] indices)
         /// <param name="value">The values to assign</param>
         /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetBoolean(bool value, params int[] indices)
+        public void SetBoolean(bool value, params int[] indices)         
         {
-            unsafe
-            {
+            unsafe {
                 *((bool*)Address + _shape.GetOffset(indices)) = value;
             }
         }
@@ -336,151 +299,62 @@ public void SetBoolean(bool value, params int[] indices)
         /// <param name="value">The values to assign</param>
         /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetByte(byte value, params int[] indices)
+        public void SetByte(byte value, params int[] indices)         
         {
-            unsafe
-            {
+            unsafe {
                 *((byte*)Address + _shape.GetOffset(indices)) = value;
             }
         }
 
-        /// <summary>
-        ///     Sets a short at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetInt16(short value, params int[] indices)
-        {
-            unsafe
-            {
-                *((short*)Address + _shape.GetOffset(indices)) = value;
-            }
-        }
-
-        /// <summary>
-        ///     Sets a ushort at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUInt16(ushort value, params int[] indices)
-        {
-            unsafe
-            {
-                *((ushort*)Address + _shape.GetOffset(indices)) = value;
-            }
-        }
-
         /// <summary>
         ///     Sets a int at specific coordinates.
         /// </summary>
         /// <param name="value">The values to assign</param>
         /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetInt32(int value, params int[] indices)
+        public void SetInt32(int value, params int[] indices)         
         {
-            unsafe
-            {
+            unsafe {
                 *((int*)Address + _shape.GetOffset(indices)) = value;
             }
         }
 
-        /// <summary>
-        ///     Sets a uint at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUInt32(uint value, params int[] indices)
-        {
-            unsafe
-            {
-                *((uint*)Address + _shape.GetOffset(indices)) = value;
-            }
-        }
-
         /// <summary>
         ///     Sets a long at specific coordinates.
         /// </summary>
         /// <param name="value">The values to assign</param>
         /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetInt64(long value, params int[] indices)
+        public void SetInt64(long value, params int[] indices)         
         {
-            unsafe
-            {
+            unsafe {
                 *((long*)Address + _shape.GetOffset(indices)) = value;
             }
         }
 
-        /// <summary>
-        ///     Sets a ulong at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetUInt64(ulong value, params int[] indices)
-        {
-            unsafe
-            {
-                *((ulong*)Address + _shape.GetOffset(indices)) = value;
-            }
-        }
-
-        /// <summary>
-        ///     Sets a char at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetChar(char value, params int[] indices)
-        {
-            unsafe
-            {
-                *((char*)Address + _shape.GetOffset(indices)) = value;
-            }
-        }
-
-        /// <summary>
-        ///     Sets a double at specific coordinates.
-        /// </summary>
-        /// <param name="value">The values to assign</param>
-        /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetDouble(double value, params int[] indices)
-        {
-            unsafe
-            {
-                *((double*)Address + _shape.GetOffset(indices)) = value;
-            }
-        }
-
         /// <summary>
         ///     Sets a float at specific coordinates.
         /// </summary>
         /// <param name="value">The values to assign</param>
         /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetSingle(float value, params int[] indices)
+        public void SetSingle(float value, params int[] indices)         
         {
-            unsafe
-            {
+            unsafe {
                 *((float*)Address + _shape.GetOffset(indices)) = value;
             }
         }
 
         /// <summary>
-        ///     Sets a decimal at specific coordinates.
+        ///     Sets a double at specific coordinates.
         /// </summary>
         /// <param name="value">The values to assign</param>
         /// <param name="indices">The coordinates to set <paramref name="value"/> at.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetDecimal(decimal value, params int[] indices)
+        public void SetDouble(double value, params int[] indices)         
         {
-            unsafe
-            {
-                *((decimal*)Address + _shape.GetOffset(indices)) = value;
+            unsafe {
+                *((double*)Address + _shape.GetOffset(indices)) = value;
             }
         }
 #endif
diff --git a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.cs b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.cs
index 31b5dc30f..a2b525ab4 100644
--- a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.cs
+++ b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.cs
@@ -25,22 +25,17 @@ namespace NumSharp.Backends
     /// </remarks>
     public partial class UnmanagedStorage : ICloneable
     {
-#if _REGEN
+#if _REGEN1
         %foreach supported_dtypes,supported_dtypes_lowercase%
         protected ArraySlice<#2> _array#1;
+        %
 #else
         protected ArraySlice<bool> _arrayBoolean;
         protected ArraySlice<byte> _arrayByte;
-        protected ArraySlice<short> _arrayInt16;
-        protected ArraySlice<ushort> _arrayUInt16;
         protected ArraySlice<int> _arrayInt32;
-        protected ArraySlice<uint> _arrayUInt32;
         protected ArraySlice<long> _arrayInt64;
-        protected ArraySlice<ulong> _arrayUInt64;
-        protected ArraySlice<char> _arrayChar;
-        protected ArraySlice<double> _arrayDouble;
         protected ArraySlice<float> _arraySingle;
-        protected ArraySlice<decimal> _arrayDecimal;
+        protected ArraySlice<double> _arrayDouble;
 #endif
         public IArraySlice InternalArray;
         public unsafe byte* Address;
@@ -212,7 +207,7 @@ public UnmanagedStorage(IArraySlice arraySlice, Shape shape)
         }
 
 
-#if _REGEN
+#if _REGEN1
         %foreach supported_dtypes,supported_dtypes_lowercase%
         public UnmanagedStorage(#2 scalar)
         {            
@@ -230,7 +225,7 @@ public UnmanagedStorage(#2 scalar)
         %
 #else
         public UnmanagedStorage(bool scalar)
-        {
+        {            
             _dtype = typeof(Boolean);
             _typecode = InfoOf<bool>.NPTypeCode;
             _shape = Shape.Scalar;
@@ -243,7 +238,7 @@ public UnmanagedStorage(bool scalar)
         }
 
         public UnmanagedStorage(byte scalar)
-        {
+        {            
             _dtype = typeof(Byte);
             _typecode = InfoOf<byte>.NPTypeCode;
             _shape = Shape.Scalar;
@@ -255,34 +250,8 @@ public UnmanagedStorage(byte scalar)
             }
         }
 
-        public UnmanagedStorage(short scalar)
-        {
-            _dtype = typeof(Int16);
-            _typecode = InfoOf<short>.NPTypeCode;
-            _shape = Shape.Scalar;
-            InternalArray = _arrayInt16 = ArraySlice.Scalar<short>(scalar);
-            unsafe
-            {
-                Address = (byte*)_arrayInt16.Address;
-                Count = _arrayInt16.Count;
-            }
-        }
-
-        public UnmanagedStorage(ushort scalar)
-        {
-            _dtype = typeof(UInt16);
-            _typecode = InfoOf<ushort>.NPTypeCode;
-            _shape = Shape.Scalar;
-            InternalArray = _arrayUInt16 = ArraySlice.Scalar<ushort>(scalar);
-            unsafe
-            {
-                Address = (byte*)_arrayUInt16.Address;
-                Count = _arrayUInt16.Count;
-            }
-        }
-
         public UnmanagedStorage(int scalar)
-        {
+        {            
             _dtype = typeof(Int32);
             _typecode = InfoOf<int>.NPTypeCode;
             _shape = Shape.Scalar;
@@ -294,21 +263,8 @@ public UnmanagedStorage(int scalar)
             }
         }
 
-        public UnmanagedStorage(uint scalar)
-        {
-            _dtype = typeof(UInt32);
-            _typecode = InfoOf<uint>.NPTypeCode;
-            _shape = Shape.Scalar;
-            InternalArray = _arrayUInt32 = ArraySlice.Scalar<uint>(scalar);
-            unsafe
-            {
-                Address = (byte*)_arrayUInt32.Address;
-                Count = _arrayUInt32.Count;
-            }
-        }
-
         public UnmanagedStorage(long scalar)
-        {
+        {            
             _dtype = typeof(Int64);
             _typecode = InfoOf<long>.NPTypeCode;
             _shape = Shape.Scalar;
@@ -320,47 +276,8 @@ public UnmanagedStorage(long scalar)
             }
         }
 
-        public UnmanagedStorage(ulong scalar)
-        {
-            _dtype = typeof(UInt64);
-            _typecode = InfoOf<ulong>.NPTypeCode;
-            _shape = Shape.Scalar;
-            InternalArray = _arrayUInt64 = ArraySlice.Scalar<ulong>(scalar);
-            unsafe
-            {
-                Address = (byte*)_arrayUInt64.Address;
-                Count = _arrayUInt64.Count;
-            }
-        }
-
-        public UnmanagedStorage(char scalar)
-        {
-            _dtype = typeof(Char);
-            _typecode = InfoOf<char>.NPTypeCode;
-            _shape = Shape.Scalar;
-            InternalArray = _arrayChar = ArraySlice.Scalar<char>(scalar);
-            unsafe
-            {
-                Address = (byte*)_arrayChar.Address;
-                Count = _arrayChar.Count;
-            }
-        }
-
-        public UnmanagedStorage(double scalar)
-        {
-            _dtype = typeof(Double);
-            _typecode = InfoOf<double>.NPTypeCode;
-            _shape = Shape.Scalar;
-            InternalArray = _arrayDouble = ArraySlice.Scalar<double>(scalar);
-            unsafe
-            {
-                Address = (byte*)_arrayDouble.Address;
-                Count = _arrayDouble.Count;
-            }
-        }
-
         public UnmanagedStorage(float scalar)
-        {
+        {            
             _dtype = typeof(Single);
             _typecode = InfoOf<float>.NPTypeCode;
             _shape = Shape.Scalar;
@@ -372,16 +289,16 @@ public UnmanagedStorage(float scalar)
             }
         }
 
-        public UnmanagedStorage(decimal scalar)
-        {
-            _dtype = typeof(Decimal);
-            _typecode = InfoOf<decimal>.NPTypeCode;
+        public UnmanagedStorage(double scalar)
+        {            
+            _dtype = typeof(Double);
+            _typecode = InfoOf<double>.NPTypeCode;
             _shape = Shape.Scalar;
-            InternalArray = _arrayDecimal = ArraySlice.Scalar<decimal>(scalar);
+            InternalArray = _arrayDouble = ArraySlice.Scalar<double>(scalar);
             unsafe
             {
-                Address = (byte*)_arrayDecimal.Address;
-                Count = _arrayDecimal.Count;
+                Address = (byte*)_arrayDouble.Address;
+                Count = _arrayDouble.Count;
             }
         }
 #endif
@@ -404,7 +321,7 @@ public UnmanagedStorage(#1[] values)
         %
 #else
         public UnmanagedStorage(Boolean[] values)
-        {
+        {            
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
             _dtype = typeof(Boolean);
@@ -417,9 +334,8 @@ public UnmanagedStorage(Boolean[] values)
                 Count = values.Length;
             }
         }
-
         public UnmanagedStorage(Byte[] values)
-        {
+        {            
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
             _dtype = typeof(Byte);
@@ -432,39 +348,8 @@ public UnmanagedStorage(Byte[] values)
                 Count = values.Length;
             }
         }
-
-        public UnmanagedStorage(Int16[] values)
-        {
-            if (values == null)
-                throw new ArgumentNullException(nameof(values));
-            _dtype = typeof(Int16);
-            _typecode = _dtype.GetTypeCode();
-            _shape = new Shape(values.Length);
-            InternalArray = _arrayInt16 = new ArraySlice<short>(UnmanagedMemoryBlock<short>.FromArray(values));
-            unsafe
-            {
-                Address = (byte*)_arrayInt16.Address;
-                Count = values.Length;
-            }
-        }
-
-        public UnmanagedStorage(UInt16[] values)
-        {
-            if (values == null)
-                throw new ArgumentNullException(nameof(values));
-            _dtype = typeof(UInt16);
-            _typecode = _dtype.GetTypeCode();
-            _shape = new Shape(values.Length);
-            InternalArray = _arrayUInt16 = new ArraySlice<ushort>(UnmanagedMemoryBlock<ushort>.FromArray(values));
-            unsafe
-            {
-                Address = (byte*)_arrayUInt16.Address;
-                Count = values.Length;
-            }
-        }
-
         public UnmanagedStorage(Int32[] values)
-        {
+        {            
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
             _dtype = typeof(Int32);
@@ -477,24 +362,8 @@ public UnmanagedStorage(Int32[] values)
                 Count = values.Length;
             }
         }
-
-        public UnmanagedStorage(UInt32[] values)
-        {
-            if (values == null)
-                throw new ArgumentNullException(nameof(values));
-            _dtype = typeof(UInt32);
-            _typecode = _dtype.GetTypeCode();
-            _shape = new Shape(values.Length);
-            InternalArray = _arrayUInt32 = new ArraySlice<uint>(UnmanagedMemoryBlock<uint>.FromArray(values));
-            unsafe
-            {
-                Address = (byte*)_arrayUInt32.Address;
-                Count = values.Length;
-            }
-        }
-
         public UnmanagedStorage(Int64[] values)
-        {
+        {            
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
             _dtype = typeof(Int64);
@@ -507,54 +376,8 @@ public UnmanagedStorage(Int64[] values)
                 Count = values.Length;
             }
         }
-
-        public UnmanagedStorage(UInt64[] values)
-        {
-            if (values == null)
-                throw new ArgumentNullException(nameof(values));
-            _dtype = typeof(UInt64);
-            _typecode = _dtype.GetTypeCode();
-            _shape = new Shape(values.Length);
-            InternalArray = _arrayUInt64 = new ArraySlice<ulong>(UnmanagedMemoryBlock<ulong>.FromArray(values));
-            unsafe
-            {
-                Address = (byte*)_arrayUInt64.Address;
-                Count = values.Length;
-            }
-        }
-
-        public UnmanagedStorage(Char[] values)
-        {
-            if (values == null)
-                throw new ArgumentNullException(nameof(values));
-            _dtype = typeof(Char);
-            _typecode = _dtype.GetTypeCode();
-            _shape = new Shape(values.Length);
-            InternalArray = _arrayChar = new ArraySlice<char>(UnmanagedMemoryBlock<char>.FromArray(values));
-            unsafe
-            {
-                Address = (byte*)_arrayChar.Address;
-                Count = values.Length;
-            }
-        }
-
-        public UnmanagedStorage(Double[] values)
-        {
-            if (values == null)
-                throw new ArgumentNullException(nameof(values));
-            _dtype = typeof(Double);
-            _typecode = _dtype.GetTypeCode();
-            _shape = new Shape(values.Length);
-            InternalArray = _arrayDouble = new ArraySlice<double>(UnmanagedMemoryBlock<double>.FromArray(values));
-            unsafe
-            {
-                Address = (byte*)_arrayDouble.Address;
-                Count = values.Length;
-            }
-        }
-
         public UnmanagedStorage(Single[] values)
-        {
+        {            
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
             _dtype = typeof(Single);
@@ -567,18 +390,17 @@ public UnmanagedStorage(Single[] values)
                 Count = values.Length;
             }
         }
-
-        public UnmanagedStorage(Decimal[] values)
-        {
+        public UnmanagedStorage(Double[] values)
+        {            
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
-            _dtype = typeof(Decimal);
+            _dtype = typeof(Double);
             _typecode = _dtype.GetTypeCode();
             _shape = new Shape(values.Length);
-            InternalArray = _arrayDecimal = new ArraySlice<decimal>(UnmanagedMemoryBlock<decimal>.FromArray(values));
+            InternalArray = _arrayDouble = new ArraySlice<double>(UnmanagedMemoryBlock<double>.FromArray(values));
             unsafe
             {
-                Address = (byte*)_arrayDecimal.Address;
+                Address = (byte*)_arrayDouble.Address;
                 Count = values.Length;
             }
         }
@@ -595,7 +417,7 @@ protected unsafe void SetInternalArray(Array array)
         {
             switch (_typecode)
             {
-#if _REGEN
+#if _REGEN1
                 //Since it is a single assignment, we do not use 'as' casting but rather explicit casting that'll also type-check.
                 %foreach supported_dtypes,supported_dtypes_lowercase%
                 case NPTypeCode.#1:
@@ -613,99 +435,45 @@ protected unsafe void SetInternalArray(Array array)
                 case NPTypeCode.Boolean:
                 {
                     InternalArray = _arrayBoolean = ArraySlice.FromArray<bool>((bool[])array);
-                    Address = (byte*)_arrayBoolean.Address;
+                    Address = (byte*) _arrayBoolean.Address;
                     Count = _arrayBoolean.Count;
                     break;
                 }
-
                 case NPTypeCode.Byte:
                 {
                     InternalArray = _arrayByte = ArraySlice.FromArray<byte>((byte[])array);
-                    Address = (byte*)_arrayByte.Address;
+                    Address = (byte*) _arrayByte.Address;
                     Count = _arrayByte.Count;
                     break;
                 }
-
-                case NPTypeCode.Int16:
-                {
-                    InternalArray = _arrayInt16 = ArraySlice.FromArray<short>((short[])array);
-                    Address = (byte*)_arrayInt16.Address;
-                    Count = _arrayInt16.Count;
-                    break;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    InternalArray = _arrayUInt16 = ArraySlice.FromArray<ushort>((ushort[])array);
-                    Address = (byte*)_arrayUInt16.Address;
-                    Count = _arrayUInt16.Count;
-                    break;
-                }
-
                 case NPTypeCode.Int32:
                 {
                     InternalArray = _arrayInt32 = ArraySlice.FromArray<int>((int[])array);
-                    Address = (byte*)_arrayInt32.Address;
+                    Address = (byte*) _arrayInt32.Address;
                     Count = _arrayInt32.Count;
                     break;
                 }
-
-                case NPTypeCode.UInt32:
-                {
-                    InternalArray = _arrayUInt32 = ArraySlice.FromArray<uint>((uint[])array);
-                    Address = (byte*)_arrayUInt32.Address;
-                    Count = _arrayUInt32.Count;
-                    break;
-                }
-
                 case NPTypeCode.Int64:
                 {
                     InternalArray = _arrayInt64 = ArraySlice.FromArray<long>((long[])array);
-                    Address = (byte*)_arrayInt64.Address;
+                    Address = (byte*) _arrayInt64.Address;
                     Count = _arrayInt64.Count;
                     break;
                 }
-
-                case NPTypeCode.UInt64:
-                {
-                    InternalArray = _arrayUInt64 = ArraySlice.FromArray<ulong>((ulong[])array);
-                    Address = (byte*)_arrayUInt64.Address;
-                    Count = _arrayUInt64.Count;
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    InternalArray = _arrayChar = ArraySlice.FromArray<char>((char[])array);
-                    Address = (byte*)_arrayChar.Address;
-                    Count = _arrayChar.Count;
-                    break;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    InternalArray = _arrayDouble = ArraySlice.FromArray<double>((double[])array);
-                    Address = (byte*)_arrayDouble.Address;
-                    Count = _arrayDouble.Count;
-                    break;
-                }
-
                 case NPTypeCode.Single:
                 {
                     InternalArray = _arraySingle = ArraySlice.FromArray<float>((float[])array);
-                    Address = (byte*)_arraySingle.Address;
+                    Address = (byte*) _arraySingle.Address;
                     Count = _arraySingle.Count;
                     break;
                 }
-
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
-                    InternalArray = _arrayDecimal = ArraySlice.FromArray<decimal>((decimal[])array);
-                    Address = (byte*)_arrayDecimal.Address;
-                    Count = _arrayDecimal.Count;
+                    InternalArray = _arrayDouble = ArraySlice.FromArray<double>((double[])array);
+                    Address = (byte*) _arrayDouble.Address;
+                    Count = _arrayDouble.Count;
                     break;
                 }
-
                 default:
                     throw new NotSupportedException();
 #endif
@@ -721,7 +489,7 @@ protected unsafe void SetInternalArray(IArraySlice array)
         {
             switch (_typecode)
             {
-#if _REGEN
+#if _REGEN1
                 //Since it is a single assignment, we do not use 'as' casting but rather explicit casting that'll also type-check.
                 %foreach supported_dtypes,supported_dtypes_lowercase%
                 case NPTypeCode.#1:
@@ -739,99 +507,45 @@ protected unsafe void SetInternalArray(IArraySlice array)
                 case NPTypeCode.Boolean:
                 {
                     InternalArray = _arrayBoolean = (ArraySlice<bool>)array;
-                    Address = (byte*)_arrayBoolean.Address;
+                    Address = (byte*) _arrayBoolean.Address;
                     Count = _arrayBoolean.Count;
                     break;
                 }
-
                 case NPTypeCode.Byte:
                 {
                     InternalArray = _arrayByte = (ArraySlice<byte>)array;
-                    Address = _arrayByte.Address;
+                    Address = (byte*) _arrayByte.Address;
                     Count = _arrayByte.Count;
                     break;
                 }
-
-                case NPTypeCode.Int16:
-                {
-                    InternalArray = _arrayInt16 = (ArraySlice<short>)array;
-                    Address = (byte*)_arrayInt16.Address;
-                    Count = _arrayInt16.Count;
-                    break;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    InternalArray = _arrayUInt16 = (ArraySlice<ushort>)array;
-                    Address = (byte*)_arrayUInt16.Address;
-                    Count = _arrayUInt16.Count;
-                    break;
-                }
-
                 case NPTypeCode.Int32:
                 {
                     InternalArray = _arrayInt32 = (ArraySlice<int>)array;
-                    Address = (byte*)_arrayInt32.Address;
+                    Address = (byte*) _arrayInt32.Address;
                     Count = _arrayInt32.Count;
                     break;
                 }
-
-                case NPTypeCode.UInt32:
-                {
-                    InternalArray = _arrayUInt32 = (ArraySlice<uint>)array;
-                    Address = (byte*)_arrayUInt32.Address;
-                    Count = _arrayUInt32.Count;
-                    break;
-                }
-
                 case NPTypeCode.Int64:
                 {
                     InternalArray = _arrayInt64 = (ArraySlice<long>)array;
-                    Address = (byte*)_arrayInt64.Address;
+                    Address = (byte*) _arrayInt64.Address;
                     Count = _arrayInt64.Count;
                     break;
                 }
-
-                case NPTypeCode.UInt64:
-                {
-                    InternalArray = _arrayUInt64 = (ArraySlice<ulong>)array;
-                    Address = (byte*)_arrayUInt64.Address;
-                    Count = _arrayUInt64.Count;
-                    break;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    InternalArray = _arrayChar = (ArraySlice<char>)array;
-                    Address = (byte*)_arrayChar.Address;
-                    Count = _arrayChar.Count;
-                    break;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    InternalArray = _arrayDouble = (ArraySlice<double>)array;
-                    Address = (byte*)_arrayDouble.Address;
-                    Count = _arrayDouble.Count;
-                    break;
-                }
-
                 case NPTypeCode.Single:
                 {
                     InternalArray = _arraySingle = (ArraySlice<float>)array;
-                    Address = (byte*)_arraySingle.Address;
+                    Address = (byte*) _arraySingle.Address;
                     Count = _arraySingle.Count;
                     break;
                 }
-
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
-                    InternalArray = _arrayDecimal = (ArraySlice<decimal>)array;
-                    Address = (byte*)_arrayDecimal.Address;
-                    Count = _arrayDecimal.Count;
+                    InternalArray = _arrayDouble = (ArraySlice<double>)array;
+                    Address = (byte*) _arrayDouble.Address;
+                    Count = _arrayDouble.Count;
                     break;
                 }
-
                 default:
                     throw new NotSupportedException();
 #endif
@@ -1062,7 +776,7 @@ public void CopyTo(IntPtr ptr)
         /// <param name="address">The address to copy to.</param>
         public unsafe void CopyTo(void* address)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 
 		    switch (TypeCode)
@@ -1084,86 +798,49 @@ public unsafe void CopyTo(void* address)
 
             #region Compute
 
-            switch (TypeCode)
-            {
-                case NPTypeCode.Boolean:
-                {
-                    CopyTo<bool>((bool*)address);
-                    break;
-                }
-
-                case NPTypeCode.Byte:
-                {
-                    CopyTo<byte>((byte*)address);
-                    break;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    CopyTo<short>((short*)address);
-                    break;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    CopyTo<ushort>((ushort*)address);
-                    break;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    CopyTo<int>((int*)address);
-                    break;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    CopyTo<uint>((uint*)address);
-                    break;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    CopyTo<long>((long*)address);
+		    switch (TypeCode)
+		    {
+			    case NPTypeCode.Boolean:
+			    {
+				    CopyTo<bool>((bool*)address);
                     break;
-                }
+			    }
 
-                case NPTypeCode.UInt64:
-                {
-                    CopyTo<ulong>((ulong*)address);
+			    case NPTypeCode.Byte:
+			    {
+				    CopyTo<byte>((byte*)address);
                     break;
-                }
+			    }
 
-                case NPTypeCode.Char:
-                {
-                    CopyTo<char>((char*)address);
+			    case NPTypeCode.Int32:
+			    {
+				    CopyTo<int>((int*)address);
                     break;
-                }
+			    }
 
-                case NPTypeCode.Double:
-                {
-                    CopyTo<double>((double*)address);
+			    case NPTypeCode.Int64:
+			    {
+				    CopyTo<long>((long*)address);
                     break;
-                }
+			    }
 
-                case NPTypeCode.Single:
-                {
-                    CopyTo<float>((float*)address);
+			    case NPTypeCode.Single:
+			    {
+				    CopyTo<float>((float*)address);
                     break;
-                }
+			    }
 
-                case NPTypeCode.Decimal:
-                {
-                    CopyTo<decimal>((decimal*)address);
+			    case NPTypeCode.Double:
+			    {
+				    CopyTo<double>((double*)address);
                     break;
-                }
+			    }
 
-                default:
-                    throw new NotSupportedException();
-            }
+			    default:
+				    throw new NotSupportedException();
+		    }
 
             #endregion
-
 #endif
         }
 
@@ -1179,7 +856,7 @@ public unsafe void CopyTo(IMemoryBlock block)
             if (Count > block.Count)
                 throw new ArgumentOutOfRangeException(nameof(block), $"Unable to copy from this storage to given memory block because this storage count is larger than the given memory block's length.");
 
-#if _REGEN
+#if _REGEN1
             #region Compute
 
 		    switch (TypeCode)
@@ -1187,7 +864,7 @@ public unsafe void CopyTo(IMemoryBlock block)
 			    %foreach supported_dtypes,supported_dtypes_lowercase%
 			    case NPTypeCode.#1:
 			    {
-				    CopyTo<#2>((#2*)slice.Address);
+				    CopyTo<#2>((#2*)block.Address);
                     break;
 			    }
 
@@ -1201,86 +878,49 @@ public unsafe void CopyTo(IMemoryBlock block)
 
             #region Compute
 
-            switch (TypeCode)
-            {
-                case NPTypeCode.Boolean:
-                {
-                    CopyTo<bool>((bool*)block.Address);
-                    break;
-                }
-
-                case NPTypeCode.Byte:
-                {
-                    CopyTo<byte>((byte*)block.Address);
-                    break;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    CopyTo<short>((short*)block.Address);
-                    break;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    CopyTo<ushort>((ushort*)block.Address);
-                    break;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    CopyTo<int>((int*)block.Address);
-                    break;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    CopyTo<uint>((uint*)block.Address);
-                    break;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    CopyTo<long>((long*)block.Address);
+		    switch (TypeCode)
+		    {
+			    case NPTypeCode.Boolean:
+			    {
+				    CopyTo<bool>((bool*)block.Address);
                     break;
-                }
+			    }
 
-                case NPTypeCode.UInt64:
-                {
-                    CopyTo<ulong>((ulong*)block.Address);
+			    case NPTypeCode.Byte:
+			    {
+				    CopyTo<byte>((byte*)block.Address);
                     break;
-                }
+			    }
 
-                case NPTypeCode.Char:
-                {
-                    CopyTo<char>((char*)block.Address);
+			    case NPTypeCode.Int32:
+			    {
+				    CopyTo<int>((int*)block.Address);
                     break;
-                }
+			    }
 
-                case NPTypeCode.Double:
-                {
-                    CopyTo<double>((double*)block.Address);
+			    case NPTypeCode.Int64:
+			    {
+				    CopyTo<long>((long*)block.Address);
                     break;
-                }
+			    }
 
-                case NPTypeCode.Single:
-                {
-                    CopyTo<float>((float*)block.Address);
+			    case NPTypeCode.Single:
+			    {
+				    CopyTo<float>((float*)block.Address);
                     break;
-                }
+			    }
 
-                case NPTypeCode.Decimal:
-                {
-                    CopyTo<decimal>((decimal*)block.Address);
+			    case NPTypeCode.Double:
+			    {
+				    CopyTo<double>((double*)block.Address);
                     break;
-                }
+			    }
 
-                default:
-                    throw new NotSupportedException();
-            }
+			    default:
+				    throw new NotSupportedException();
+		    }
 
             #endregion
-
 #endif
         }
 
diff --git a/src/NumSharp.Core/Casting/Implicit/NdArray.Implicit.Array.cs b/src/NumSharp.Core/Casting/Implicit/NdArray.Implicit.Array.cs
index 1058da964..f9756edfe 100644
--- a/src/NumSharp.Core/Casting/Implicit/NdArray.Implicit.Array.cs
+++ b/src/NumSharp.Core/Casting/Implicit/NdArray.Implicit.Array.cs
@@ -36,25 +36,19 @@ public static implicit operator NDArray(Array array)
                 var nd = new NDArray(underlying);
                 switch (nd.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
 	                %foreach supported_dtypes,supported_dtypes_lowercase%
 	                case NPTypeCode.#1: return NDArray.FromJaggedArray<#2>(array);
 	                %
 	                default:
 		                throw new NotSupportedException();
 #else
-                    case NPTypeCode.Boolean: return NDArray.FromJaggedArray<bool>(array);
+	                case NPTypeCode.Boolean: return NDArray.FromJaggedArray<bool>(array);
 	                case NPTypeCode.Byte: return NDArray.FromJaggedArray<byte>(array);
-	                case NPTypeCode.Int16: return NDArray.FromJaggedArray<short>(array);
-	                case NPTypeCode.UInt16: return NDArray.FromJaggedArray<ushort>(array);
 	                case NPTypeCode.Int32: return NDArray.FromJaggedArray<int>(array);
-	                case NPTypeCode.UInt32: return NDArray.FromJaggedArray<uint>(array);
 	                case NPTypeCode.Int64: return NDArray.FromJaggedArray<long>(array);
-	                case NPTypeCode.UInt64: return NDArray.FromJaggedArray<ulong>(array);
-	                case NPTypeCode.Char: return NDArray.FromJaggedArray<char>(array);
-	                case NPTypeCode.Double: return NDArray.FromJaggedArray<double>(array);
 	                case NPTypeCode.Single: return NDArray.FromJaggedArray<float>(array);
-	                case NPTypeCode.Decimal: return NDArray.FromJaggedArray<decimal>(array);
+	                case NPTypeCode.Double: return NDArray.FromJaggedArray<double>(array);
 	                default:
 		                throw new NotSupportedException();
 #endif
@@ -66,25 +60,19 @@ public static implicit operator NDArray(Array array)
                 var nd = new NDArray(underlying);
                 switch (nd.GetTypeCode)
                 {
-#if _REGEN
+#if _REGEN1
 	                %foreach supported_dtypes,supported_dtypes_lowercase%
 	                case NPTypeCode.#1: return NDArray.FromMultiDimArray<#2>(array);
 	                %
 	                default:
 		                throw new NotSupportedException();
 #else
-                    case NPTypeCode.Boolean: return NDArray.FromMultiDimArray<bool>(array);
+	                case NPTypeCode.Boolean: return NDArray.FromMultiDimArray<bool>(array);
 	                case NPTypeCode.Byte: return NDArray.FromMultiDimArray<byte>(array);
-	                case NPTypeCode.Int16: return NDArray.FromMultiDimArray<short>(array);
-	                case NPTypeCode.UInt16: return NDArray.FromMultiDimArray<ushort>(array);
 	                case NPTypeCode.Int32: return NDArray.FromMultiDimArray<int>(array);
-	                case NPTypeCode.UInt32: return NDArray.FromMultiDimArray<uint>(array);
 	                case NPTypeCode.Int64: return NDArray.FromMultiDimArray<long>(array);
-	                case NPTypeCode.UInt64: return NDArray.FromMultiDimArray<ulong>(array);
-	                case NPTypeCode.Char: return NDArray.FromMultiDimArray<char>(array);
-	                case NPTypeCode.Double: return NDArray.FromMultiDimArray<double>(array);
 	                case NPTypeCode.Single: return NDArray.FromMultiDimArray<float>(array);
-	                case NPTypeCode.Decimal: return NDArray.FromMultiDimArray<decimal>(array);
+	                case NPTypeCode.Double: return NDArray.FromMultiDimArray<double>(array);
 	                default:
 		                throw new NotSupportedException();
 #endif
@@ -98,7 +86,7 @@ public static explicit operator Array(NDArray nd)
         {
             switch (nd.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return nd.ToMuliDimArray<#2>();
 	            %
@@ -107,16 +95,10 @@ public static explicit operator Array(NDArray nd)
 #else
 	            case NPTypeCode.Boolean: return nd.ToMuliDimArray<bool>();
 	            case NPTypeCode.Byte: return nd.ToMuliDimArray<byte>();
-	            case NPTypeCode.Int16: return nd.ToMuliDimArray<short>();
-	            case NPTypeCode.UInt16: return nd.ToMuliDimArray<ushort>();
 	            case NPTypeCode.Int32: return nd.ToMuliDimArray<int>();
-	            case NPTypeCode.UInt32: return nd.ToMuliDimArray<uint>();
 	            case NPTypeCode.Int64: return nd.ToMuliDimArray<long>();
-	            case NPTypeCode.UInt64: return nd.ToMuliDimArray<ulong>();
-	            case NPTypeCode.Char: return nd.ToMuliDimArray<char>();
-	            case NPTypeCode.Double: return nd.ToMuliDimArray<double>();
 	            case NPTypeCode.Single: return nd.ToMuliDimArray<float>();
-	            case NPTypeCode.Decimal: return nd.ToMuliDimArray<decimal>();
+	            case NPTypeCode.Double: return nd.ToMuliDimArray<double>();
 	            default:
 		            throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Creation/np.array.cs b/src/NumSharp.Core/Creation/np.array.cs
index 99a5d6648..f765805ec 100644
--- a/src/NumSharp.Core/Creation/np.array.cs
+++ b/src/NumSharp.Core/Creation/np.array.cs
@@ -344,7 +344,7 @@ public static NDArray array<T>(T[][][][][] data) where T : unmanaged
             }
         }
 
-#if _REGEN
+#if _REGEN1
         %l = "data.GetLength("
         %r = ")"
         %foreach range(1,16)%
@@ -381,12 +381,12 @@ public static NDArray array<T>(T[#(repeat(",", i))] data, bool copy = true) wher
         /// </param>
         /// <returns>An <see cref="NDArray"/> with the data and shape of the given array.</returns>
         /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.array.html</remarks>
-        public static NDArray array<T>(T[] data, bool copy) where T : unmanaged
+        public static NDArray array<T>(T[] data, bool copy = true) where T : unmanaged
         {
             if (data == null)
                 throw new ArgumentNullException(nameof(data));
 
-            return new NDArray(ArraySlice.FromArray(data, copy), new Shape(data.Length));
+            return new NDArray(ArraySlice.FromArray(data, copy), new Shape(data.GetLength(0)));
         }
 
         /// <summary>
diff --git a/src/NumSharp.Core/Creation/np.concatenate.cs b/src/NumSharp.Core/Creation/np.concatenate.cs
index 1ae31fab5..a50a5ff2d 100644
--- a/src/NumSharp.Core/Creation/np.concatenate.cs
+++ b/src/NumSharp.Core/Creation/np.concatenate.cs
@@ -104,7 +104,7 @@ public static NDArray concatenate(NDArray[] arrays, int axis = 0)
         }
 
 
-#if _REGEN
+#if _REGEN1
         %pre = "arrays.Item"
         %foreach range(2,8)%
         /// <summary>
diff --git a/src/NumSharp.Core/Creation/np.dtype.cs b/src/NumSharp.Core/Creation/np.dtype.cs
index 9fb2e6583..b8973eb65 100644
--- a/src/NumSharp.Core/Creation/np.dtype.cs
+++ b/src/NumSharp.Core/Creation/np.dtype.cs
@@ -184,26 +184,19 @@ public static DType dtype(string dtype)
             {
                 switch (code)
                 {
-#if _REGEN
+#if _REGEN1
 	                %foreach all_dtypes%
 	                case NPTypeCode.#1: return new DType(typeof(#1));
 	                %
 	                default:
 		                throw new NotSupportedException();
 #else
-                    case NPTypeCode.Complex: return new DType(typeof(Complex));
 	                case NPTypeCode.Boolean: return new DType(typeof(Boolean));
 	                case NPTypeCode.Byte: return new DType(typeof(Byte));
-	                case NPTypeCode.Int16: return new DType(typeof(Int16));
-	                case NPTypeCode.UInt16: return new DType(typeof(UInt16));
 	                case NPTypeCode.Int32: return new DType(typeof(Int32));
-	                case NPTypeCode.UInt32: return new DType(typeof(UInt32));
 	                case NPTypeCode.Int64: return new DType(typeof(Int64));
-	                case NPTypeCode.UInt64: return new DType(typeof(UInt64));
-	                case NPTypeCode.Char: return new DType(typeof(Char));
-	                case NPTypeCode.Double: return new DType(typeof(Double));
 	                case NPTypeCode.Single: return new DType(typeof(Single));
-	                case NPTypeCode.Decimal: return new DType(typeof(Decimal));
+	                case NPTypeCode.Double: return new DType(typeof(Double));
 	                case NPTypeCode.String: return new DType(typeof(String));
 	                default:
 		                throw new NotSupportedException();
diff --git a/src/NumSharp.Core/Creation/np.frombuffer.cs b/src/NumSharp.Core/Creation/np.frombuffer.cs
index 36a5aba70..6e60aa591 100644
--- a/src/NumSharp.Core/Creation/np.frombuffer.cs
+++ b/src/NumSharp.Core/Creation/np.frombuffer.cs
@@ -34,12 +34,10 @@ public static NDArray frombuffer(byte[] bytes, string dtype)
         {
             if (dtype == ">u4")
             {
-                var size = bytes.Length / InfoOf<uint>.Size;
-                var ints = new uint[size];
+                var size = bytes.Length / InfoOf<int>.Size;
+                var ints = new int[size];
                 for (var index = 0; index < size; index++)
-                {
-                    ints[index] = (uint)(bytes[0] * 256 + bytes[1] + bytes[2] * 256 + bytes[3]);
-                }
+                    ints[index] = bytes[0] * 256 + bytes[1] + bytes[2] * 256 + bytes[3];
 
                 return new NDArray(ints);
             }
diff --git a/src/NumSharp.Core/Creation/np.linspace.cs b/src/NumSharp.Core/Creation/np.linspace.cs
index 526f4428c..e96c4a23c 100644
--- a/src/NumSharp.Core/Creation/np.linspace.cs
+++ b/src/NumSharp.Core/Creation/np.linspace.cs
@@ -76,7 +76,7 @@ public static NDArray linspace(double start, double stop, int num, bool endpoint
 
             switch (ret.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            case NPTypeCode.Boolean:
 	            {
                     unsafe
@@ -102,7 +102,7 @@ public static NDArray linspace(double start, double stop, int num, bool endpoint
 	            default:
 		            throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean:
+	            case NPTypeCode.Boolean:
 	            {
                     unsafe
                     {
@@ -120,26 +120,6 @@ public static NDArray linspace(double start, double stop, int num, bool endpoint
                         Parallel.For(0, num, i => *(addr + i) = Converts.ToByte(start + i * step));
                     }
 
-                    return ret;
-	            }
-	            case NPTypeCode.Int16:
-	            {
-                    unsafe
-                    {
-                        var addr = (short*)ret.Address;
-                        Parallel.For(0, num, i => *(addr + i) = Converts.ToInt16(start + i * step));
-                    }
-
-                    return ret;
-	            }
-	            case NPTypeCode.UInt16:
-	            {
-                    unsafe
-                    {
-                        var addr = (ushort*)ret.Address;
-                        Parallel.For(0, num, i => *(addr + i) = Converts.ToUInt16(start + i * step));
-                    }
-
                     return ret;
 	            }
 	            case NPTypeCode.Int32:
@@ -150,16 +130,6 @@ public static NDArray linspace(double start, double stop, int num, bool endpoint
                         Parallel.For(0, num, i => *(addr + i) = Converts.ToInt32(start + i * step));
                     }
 
-                    return ret;
-	            }
-	            case NPTypeCode.UInt32:
-	            {
-                    unsafe
-                    {
-                        var addr = (uint*)ret.Address;
-                        Parallel.For(0, num, i => *(addr + i) = Converts.ToUInt32(start + i * step));
-                    }
-
                     return ret;
 	            }
 	            case NPTypeCode.Int64:
@@ -170,36 +140,6 @@ public static NDArray linspace(double start, double stop, int num, bool endpoint
                         Parallel.For(0, num, i => *(addr + i) = Converts.ToInt64(start + i * step));
                     }
 
-                    return ret;
-	            }
-	            case NPTypeCode.UInt64:
-	            {
-                    unsafe
-                    {
-                        var addr = (ulong*)ret.Address;
-                        Parallel.For(0, num, i => *(addr + i) = Converts.ToUInt64(start + i * step));
-                    }
-
-                    return ret;
-	            }
-	            case NPTypeCode.Char:
-	            {
-                    unsafe
-                    {
-                        var addr = (char*)ret.Address;
-                        Parallel.For(0, num, i => *(addr + i) = Converts.ToChar(start + i * step));
-                    }
-
-                    return ret;
-	            }
-	            case NPTypeCode.Double:
-	            {
-                    unsafe
-                    {
-                        var addr = (double*)ret.Address;
-                        Parallel.For(0, num, i => *(addr + i) = Converts.ToDouble(start + i * step));
-                    }
-
                     return ret;
 	            }
 	            case NPTypeCode.Single:
@@ -212,12 +152,12 @@ public static NDArray linspace(double start, double stop, int num, bool endpoint
 
                     return ret;
 	            }
-	            case NPTypeCode.Decimal:
+	            case NPTypeCode.Double:
 	            {
                     unsafe
                     {
-                        var addr = (decimal*)ret.Address;
-                        Parallel.For(0, num, i => *(addr + i) = Converts.ToDecimal(start + i * step));
+                        var addr = (double*)ret.Address;
+                        Parallel.For(0, num, i => *(addr + i) = Converts.ToDouble(start + i * step));
                     }
 
                     return ret;
diff --git a/src/NumSharp.Core/Logic/np.all.cs b/src/NumSharp.Core/Logic/np.all.cs
index 59111e9cb..6a895b80e 100644
--- a/src/NumSharp.Core/Logic/np.all.cs
+++ b/src/NumSharp.Core/Logic/np.all.cs
@@ -12,7 +12,7 @@ public static partial class np
         /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.all.html</remarks>
         public static bool all(NDArray a)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (a.typecode)
 		    {
@@ -30,16 +30,10 @@ public static bool all(NDArray a)
 		    {
 			    case NPTypeCode.Boolean: return _all_linear<bool>(a.MakeGeneric<bool>());
 			    case NPTypeCode.Byte: return _all_linear<byte>(a.MakeGeneric<byte>());
-			    case NPTypeCode.Int16: return _all_linear<short>(a.MakeGeneric<short>());
-			    case NPTypeCode.UInt16: return _all_linear<ushort>(a.MakeGeneric<ushort>());
 			    case NPTypeCode.Int32: return _all_linear<int>(a.MakeGeneric<int>());
-			    case NPTypeCode.UInt32: return _all_linear<uint>(a.MakeGeneric<uint>());
 			    case NPTypeCode.Int64: return _all_linear<long>(a.MakeGeneric<long>());
-			    case NPTypeCode.UInt64: return _all_linear<ulong>(a.MakeGeneric<ulong>());
-			    case NPTypeCode.Char: return _all_linear<char>(a.MakeGeneric<char>());
-			    case NPTypeCode.Double: return _all_linear<double>(a.MakeGeneric<double>());
 			    case NPTypeCode.Single: return _all_linear<float>(a.MakeGeneric<float>());
-			    case NPTypeCode.Decimal: return _all_linear<decimal>(a.MakeGeneric<decimal>());
+			    case NPTypeCode.Double: return _all_linear<double>(a.MakeGeneric<double>());
 			    default:
 				    throw new NotSupportedException();
 		    }
diff --git a/src/NumSharp.Core/Logic/np.any.cs b/src/NumSharp.Core/Logic/np.any.cs
index 4dd393e4a..3c0b3ef03 100644
--- a/src/NumSharp.Core/Logic/np.any.cs
+++ b/src/NumSharp.Core/Logic/np.any.cs
@@ -13,7 +13,7 @@ public static partial class np
         /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.any.html</remarks>
         public static bool any(NDArray a)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (a.typecode)
 		    {
@@ -27,23 +27,17 @@ public static bool any(NDArray a)
 #else
 
             #region Compute
-            switch (a.typecode)
-            {
-                case NPTypeCode.Boolean: return _any_linear<bool>(a.MakeGeneric<bool>());
-                case NPTypeCode.Byte: return _any_linear<byte>(a.MakeGeneric<byte>());
-                case NPTypeCode.Int16: return _any_linear<short>(a.MakeGeneric<short>());
-                case NPTypeCode.UInt16: return _any_linear<ushort>(a.MakeGeneric<ushort>());
-                case NPTypeCode.Int32: return _any_linear<int>(a.MakeGeneric<int>());
-                case NPTypeCode.UInt32: return _any_linear<uint>(a.MakeGeneric<uint>());
-                case NPTypeCode.Int64: return _any_linear<long>(a.MakeGeneric<long>());
-                case NPTypeCode.UInt64: return _any_linear<ulong>(a.MakeGeneric<ulong>());
-                case NPTypeCode.Char: return _any_linear<char>(a.MakeGeneric<char>());
-                case NPTypeCode.Double: return _any_linear<double>(a.MakeGeneric<double>());
-                case NPTypeCode.Single: return _any_linear<float>(a.MakeGeneric<float>());
-                case NPTypeCode.Decimal: return _any_linear<decimal>(a.MakeGeneric<decimal>());
-                default:
-                    throw new NotSupportedException();
-            }
+		    switch (a.typecode)
+		    {
+			    case NPTypeCode.Boolean: return _any_linear<bool>(a.MakeGeneric<bool>());
+			    case NPTypeCode.Byte: return _any_linear<byte>(a.MakeGeneric<byte>());
+			    case NPTypeCode.Int32: return _any_linear<int>(a.MakeGeneric<int>());
+			    case NPTypeCode.Int64: return _any_linear<long>(a.MakeGeneric<long>());
+			    case NPTypeCode.Single: return _any_linear<float>(a.MakeGeneric<float>());
+			    case NPTypeCode.Double: return _any_linear<double>(a.MakeGeneric<double>());
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
 #endif
         }
diff --git a/src/NumSharp.Core/Logic/np.logical_and.cs b/src/NumSharp.Core/Logic/np.logical_and.cs
new file mode 100644
index 000000000..fc9e73e54
--- /dev/null
+++ b/src/NumSharp.Core/Logic/np.logical_and.cs
@@ -0,0 +1,226 @@
+using System;
+using NumSharp.Backends;
+using NumSharp.Generic;
+using NumSharp.Utilities;
+
+namespace NumSharp
+{
+    public static partial class np
+    {
+        /// <summary>
+        ///     Compute the truth value of x1 AND x2 element-wise.
+        /// </summary>
+        /// <param name="lhs">Input boolean array.</param>
+        /// <param name="rhs">Input boolean array.</param>
+        /// <returns>Returns True if the arrays are equal.</returns>
+        /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.logical_and.html</remarks>
+        public static unsafe NDArray<bool> logical_and(NDArray lhs, NDArray rhs)
+        {
+#if _REGEN1
+            if(lhs.typecode != rhs.typecode)
+            {
+                throw new NotImplementedException("please make sure operands have the same data type");
+            }
+            else if (lhs.typecode == NPTypeCode.Boolean)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(bool*)lhs.Address && *(bool*)rhs.Address).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (bool*)lhs.Address;
+                var rhs_address = (bool*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) && *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+            %op = "&&"
+	        %foreach except(supported_dtypes, "Boolean"), except(supported_dtypes_lowercase, "bool")%
+            else if (lhs.typecode == NPTypeCode.#1)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(#2*)lhs.Address > 0 && *(#2*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (#2*)lhs.Address;
+                var rhs_address = (#2*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) && (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            %
+            else
+            {
+                throw new NotImplementedException($"{lhs.typecode} && {rhs.typecode}");
+            }
+#else
+
+            if(lhs.typecode != rhs.typecode)
+            {
+                throw new NotImplementedException("please make sure operands have the same data type");
+            }
+            else if (lhs.typecode == NPTypeCode.Boolean)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(bool*)lhs.Address && *(bool*)rhs.Address).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (bool*)lhs.Address;
+                var rhs_address = (bool*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) && *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+            else if (lhs.typecode == NPTypeCode.Byte)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(byte*)lhs.Address > 0 && *(byte*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (byte*)lhs.Address;
+                var rhs_address = (byte*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) && (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Int32)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(int*)lhs.Address > 0 && *(int*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (int*)lhs.Address;
+                var rhs_address = (int*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) && (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Int64)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(long*)lhs.Address > 0 && *(long*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (long*)lhs.Address;
+                var rhs_address = (long*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) && (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Single)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(float*)lhs.Address > 0 && *(float*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (float*)lhs.Address;
+                var rhs_address = (float*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) && (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Double)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(double*)lhs.Address > 0 && *(double*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (double*)lhs.Address;
+                var rhs_address = (double*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) && (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else
+            {
+                throw new NotImplementedException($"{lhs.typecode} && {rhs.typecode}");
+            }
+#endif
+        }
+    }
+}
diff --git a/src/NumSharp.Core/Logic/np.logical_or.cs b/src/NumSharp.Core/Logic/np.logical_or.cs
new file mode 100644
index 000000000..4739b525e
--- /dev/null
+++ b/src/NumSharp.Core/Logic/np.logical_or.cs
@@ -0,0 +1,226 @@
+using System;
+using NumSharp.Backends;
+using NumSharp.Generic;
+using NumSharp.Utilities;
+
+namespace NumSharp
+{
+    public static partial class np
+    {
+        /// <summary>
+        ///     Compute the truth value of x1 OR x2 element-wise.
+        /// </summary>
+        /// <param name="lhs">Input boolean array.</param>
+        /// <param name="rhs">Input boolean array.</param>
+        /// <returns>Returns True if the arrays are equal.</returns>
+        /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.logical_or.html</remarks>
+        public static unsafe NDArray<bool> logical_or(NDArray lhs, NDArray rhs)
+        {
+#if _REGEN1
+            if(lhs.typecode != rhs.typecode)
+            {
+                throw new NotImplementedException("please make sure operands have the same data type");
+            }
+            else if (lhs.typecode == NPTypeCode.Boolean)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(bool*)lhs.Address || *(bool*)rhs.Address).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (bool*)lhs.Address;
+                var rhs_address = (bool*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) || *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+            %op = "&&"
+	        %foreach except(supported_dtypes, "Boolean"), except(supported_dtypes_lowercase, "bool")%
+            else if (lhs.typecode == NPTypeCode.#1)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(#2*)lhs.Address > 0 || *(#2*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (#2*)lhs.Address;
+                var rhs_address = (#2*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) || (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            %
+            else
+            {
+                throw new NotImplementedException($"{lhs.typecode} && {rhs.typecode}");
+            }
+#else
+
+            if(lhs.typecode != rhs.typecode)
+            {
+                throw new NotImplementedException("please make sure operands have the same data type");
+            }
+            else if (lhs.typecode == NPTypeCode.Boolean)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(bool*)lhs.Address || *(bool*)rhs.Address).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (bool*)lhs.Address;
+                var rhs_address = (bool*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) || *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+            else if (lhs.typecode == NPTypeCode.Byte)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(byte*)lhs.Address > 0 || *(byte*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (byte*)lhs.Address;
+                var rhs_address = (byte*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) || (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Int32)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(int*)lhs.Address > 0 || *(int*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (int*)lhs.Address;
+                var rhs_address = (int*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) || (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Int64)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(long*)lhs.Address > 0 || *(long*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (long*)lhs.Address;
+                var rhs_address = (long*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) || (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Single)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(float*)lhs.Address > 0 || *(float*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (float*)lhs.Address;
+                var rhs_address = (float*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) || (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Double)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar(*(double*)lhs.Address > 0 || *(double*)rhs.Address > 0).MakeGeneric<bool>();
+
+                var (BroadcastedLeftShape, BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (double*)lhs.Address;
+                var rhs_address = (double*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) > 0) || (*(rhs_address + BroadcastedRightShape.GetOffset(current)) > 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else
+            {
+                throw new NotImplementedException($"{lhs.typecode} && {rhs.typecode}");
+            }
+#endif
+        }
+    }
+}
diff --git a/src/NumSharp.Core/Manipulation/NDArray.unique.cs b/src/NumSharp.Core/Manipulation/NDArray.unique.cs
index 4d885089b..80ffcfc2a 100644
--- a/src/NumSharp.Core/Manipulation/NDArray.unique.cs
+++ b/src/NumSharp.Core/Manipulation/NDArray.unique.cs
@@ -23,25 +23,19 @@ public NDArray unique()
         {
             switch (typecode)
             {
-#if _REGEN
+#if _REGEN1
 	        %foreach supported_dtypes,supported_dtypes_lowercase%
 	        case NPTypeCode.#1: return unique<#2>();
             %
             default: throw new NotSupportedException();
 #else
-                case NPTypeCode.Boolean: return unique<bool>();
-                case NPTypeCode.Byte: return unique<byte>();
-                case NPTypeCode.Int16: return unique<short>();
-                case NPTypeCode.UInt16: return unique<ushort>();
-                case NPTypeCode.Int32: return unique<int>();
-                case NPTypeCode.UInt32: return unique<uint>();
-                case NPTypeCode.Int64: return unique<long>();
-                case NPTypeCode.UInt64: return unique<ulong>();
-                case NPTypeCode.Char: return unique<char>();
-                case NPTypeCode.Double: return unique<double>();
-                case NPTypeCode.Single: return unique<float>();
-                case NPTypeCode.Decimal: return unique<decimal>();
-                default: throw new NotSupportedException();
+	        case NPTypeCode.Boolean: return unique<bool>();
+	        case NPTypeCode.Byte: return unique<byte>();
+	        case NPTypeCode.Int32: return unique<int>();
+	        case NPTypeCode.Int64: return unique<long>();
+	        case NPTypeCode.Single: return unique<float>();
+	        case NPTypeCode.Double: return unique<double>();
+            default: throw new NotSupportedException();
 #endif
             }
         }
diff --git a/src/NumSharp.Core/Manipulation/np.repeat.cs b/src/NumSharp.Core/Manipulation/np.repeat.cs
index 30f6a694a..b120d38dc 100644
--- a/src/NumSharp.Core/Manipulation/np.repeat.cs
+++ b/src/NumSharp.Core/Manipulation/np.repeat.cs
@@ -21,7 +21,7 @@ public static NDArray repeat(NDArray a, int repeats) //TODO! , int axis = -1
             a = a.ravel();
             switch (a.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1:
 	            {
@@ -54,24 +54,6 @@ public static NDArray repeat(NDArray a, int repeats) //TODO! , int axis = -1
                         ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
                     return ret;
 	            }
-	            case NPTypeCode.Int16:
-	            {
-		            var ret = new NDArray(NPTypeCode.Int16, Shape.Vector(size));
-                    var data = a.MakeGeneric<short>();
-                    for (int i = 0; i < a.size; i++)
-                    for (int j = 0; j < repeats; j++)
-                        ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
-                    return ret;
-	            }
-	            case NPTypeCode.UInt16:
-	            {
-		            var ret = new NDArray(NPTypeCode.UInt16, Shape.Vector(size));
-                    var data = a.MakeGeneric<ushort>();
-                    for (int i = 0; i < a.size; i++)
-                    for (int j = 0; j < repeats; j++)
-                        ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
-                    return ret;
-	            }
 	            case NPTypeCode.Int32:
 	            {
 		            var ret = new NDArray(NPTypeCode.Int32, Shape.Vector(size));
@@ -81,15 +63,6 @@ public static NDArray repeat(NDArray a, int repeats) //TODO! , int axis = -1
                         ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
                     return ret;
 	            }
-	            case NPTypeCode.UInt32:
-	            {
-		            var ret = new NDArray(NPTypeCode.UInt32, Shape.Vector(size));
-                    var data = a.MakeGeneric<uint>();
-                    for (int i = 0; i < a.size; i++)
-                    for (int j = 0; j < repeats; j++)
-                        ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
-                    return ret;
-	            }
 	            case NPTypeCode.Int64:
 	            {
 		            var ret = new NDArray(NPTypeCode.Int64, Shape.Vector(size));
@@ -99,33 +72,6 @@ public static NDArray repeat(NDArray a, int repeats) //TODO! , int axis = -1
                         ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
                     return ret;
 	            }
-	            case NPTypeCode.UInt64:
-	            {
-		            var ret = new NDArray(NPTypeCode.UInt64, Shape.Vector(size));
-                    var data = a.MakeGeneric<ulong>();
-                    for (int i = 0; i < a.size; i++)
-                    for (int j = 0; j < repeats; j++)
-                        ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
-                    return ret;
-	            }
-	            case NPTypeCode.Char:
-	            {
-		            var ret = new NDArray(NPTypeCode.Char, Shape.Vector(size));
-                    var data = a.MakeGeneric<char>();
-                    for (int i = 0; i < a.size; i++)
-                    for (int j = 0; j < repeats; j++)
-                        ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
-                    return ret;
-	            }
-	            case NPTypeCode.Double:
-	            {
-		            var ret = new NDArray(NPTypeCode.Double, Shape.Vector(size));
-                    var data = a.MakeGeneric<double>();
-                    for (int i = 0; i < a.size; i++)
-                    for (int j = 0; j < repeats; j++)
-                        ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
-                    return ret;
-	            }
 	            case NPTypeCode.Single:
 	            {
 		            var ret = new NDArray(NPTypeCode.Single, Shape.Vector(size));
@@ -135,10 +81,10 @@ public static NDArray repeat(NDArray a, int repeats) //TODO! , int axis = -1
                         ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
                     return ret;
 	            }
-	            case NPTypeCode.Decimal:
+	            case NPTypeCode.Double:
 	            {
-		            var ret = new NDArray(NPTypeCode.Decimal, Shape.Vector(size));
-                    var data = a.MakeGeneric<decimal>();
+		            var ret = new NDArray(NPTypeCode.Double, Shape.Vector(size));
+                    var data = a.MakeGeneric<double>();
                     for (int i = 0; i < a.size; i++)
                     for (int j = 0; j < repeats; j++)
                         ret.itemset(new int[1] {i * repeats + j}, data.GetAtIndex(i));
diff --git a/src/NumSharp.Core/Math/NDArray.negative.cs b/src/NumSharp.Core/Math/NDArray.negative.cs
index d8b10b0b4..3abbeb482 100644
--- a/src/NumSharp.Core/Math/NDArray.negative.cs
+++ b/src/NumSharp.Core/Math/NDArray.negative.cs
@@ -29,7 +29,7 @@ public NDArray negative()
                             *(out_addr + i) = !*(addr + i);
                         return @out;
                     }
-#if _REGEN
+#if _REGEN1
                     %foreach supported_numericals_signed,supported_numericals_signed_lowercase%
 	                case NPTypeCode.#1:
 	                {
@@ -48,17 +48,6 @@ public NDArray negative()
 	                default:
 		                throw new NotSupportedException();
 #else
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-
-                        for (int i = 0; i < len; i++) {
-                            var val = *(out_addr + i);
-                            if (val > 0)
-                                *(out_addr + i) = (short) -val;
-                        }
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
@@ -74,17 +63,6 @@ public NDArray negative()
 	                {
                         var out_addr = (long*)@out.Address;
 
-                        for (int i = 0; i < len; i++) {
-                            var val = *(out_addr + i);
-                            if (val > 0)
-                                *(out_addr + i) = -val;
-                        }
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-
                         for (int i = 0; i < len; i++) {
                             var val = *(out_addr + i);
                             if (val > 0)
@@ -103,9 +81,9 @@ public NDArray negative()
                         }
                         return @out;
 	                }
-	                case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
+                        var out_addr = (double*)@out.Address;
 
                         for (int i = 0; i < len; i++) {
                             var val = *(out_addr + i);
@@ -118,7 +96,6 @@ public NDArray negative()
 	                case NPTypeCode.UInt16:
 	                case NPTypeCode.UInt32:
 	                case NPTypeCode.UInt64:
-	                case NPTypeCode.Char:
 	                default:
 		                throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Math/NDArray.positive.cs b/src/NumSharp.Core/Math/NDArray.positive.cs
index 4bf409d48..1b195a5c8 100644
--- a/src/NumSharp.Core/Math/NDArray.positive.cs
+++ b/src/NumSharp.Core/Math/NDArray.positive.cs
@@ -28,7 +28,7 @@ public NDArray positive()
                             *(out_addr + i) = !*(addr + i);
                         return @out;
                     }
-#if _REGEN
+#if _REGEN1
                     %foreach supported_numericals_signed,supported_numericals_signed_lowercase%
 	                case NPTypeCode.#1:
 	                {
@@ -47,17 +47,6 @@ public NDArray positive()
 	                default:
 		                throw new NotSupportedException();
 #else
-	                case NPTypeCode.Int16:
-	                {
-                        var out_addr = (short*)@out.Address;
-
-                        for (int i = 0; i < len; i++) {
-                            var val = *(out_addr + i);
-                            if (val < 0)
-                                *(out_addr + i) = (short) -val;
-                        }
-                        return @out;
-	                }
 	                case NPTypeCode.Int32:
 	                {
                         var out_addr = (int*)@out.Address;
@@ -73,17 +62,6 @@ public NDArray positive()
 	                {
                         var out_addr = (long*)@out.Address;
 
-                        for (int i = 0; i < len; i++) {
-                            var val = *(out_addr + i);
-                            if (val < 0)
-                                *(out_addr + i) = -val;
-                        }
-                        return @out;
-	                }
-	                case NPTypeCode.Double:
-	                {
-                        var out_addr = (double*)@out.Address;
-
                         for (int i = 0; i < len; i++) {
                             var val = *(out_addr + i);
                             if (val < 0)
@@ -102,9 +80,9 @@ public NDArray positive()
                         }
                         return @out;
 	                }
-	                case NPTypeCode.Decimal:
+	                case NPTypeCode.Double:
 	                {
-                        var out_addr = (decimal*)@out.Address;
+                        var out_addr = (double*)@out.Address;
 
                         for (int i = 0; i < len; i++) {
                             var val = *(out_addr + i);
@@ -117,7 +95,6 @@ public NDArray positive()
 	                case NPTypeCode.UInt16:
 	                case NPTypeCode.UInt32:
 	                case NPTypeCode.UInt64:
-	                case NPTypeCode.Char:
 	                default:
 		                throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/NumSharp.Core.csproj b/src/NumSharp.Core/NumSharp.Core.csproj
index 8dcf42a43..d34872c15 100644
--- a/src/NumSharp.Core/NumSharp.Core.csproj
+++ b/src/NumSharp.Core/NumSharp.Core.csproj
@@ -11,9 +11,10 @@
     <PackageProjectUrl>https://github.com/SciSharp</PackageProjectUrl>
     <Copyright>2019 © SciSharp STACK Team</Copyright>
     <RepositoryUrl>https://github.com/SciSharp/NumSharp</RepositoryUrl>
-    <PackageReleaseNotes>Rewrite of the NDArray's getter mechanism. Added np.nonzero, np.maximum, np.minimum, np.all, np.any. np.clip: Added @out argument. Added NPTypeCode.Float as an alias to NPTypeCode.Single.</PackageReleaseNotes>
-    <AssemblyVersion>0.20.5</AssemblyVersion>
-    <FileVersion>0.20.5</FileVersion>
+    <PackageReleaseNotes>NumSharp compact version.
+Removed Int16, UInt16, UInt32, UInt64, Decimal and Char datatypes.</PackageReleaseNotes>
+    <AssemblyVersion>0.30.0</AssemblyVersion>
+    <FileVersion>0.30.0</FileVersion>
     <RepositoryType>git</RepositoryType>
     <PackageTags>Numpy, NumSharp, MachineLearning, Math, Scientific, Numeric, Mathlab, SciSharp</PackageTags>
     <PackageLicenseUrl></PackageLicenseUrl>
@@ -23,7 +24,7 @@
     <Product>NumSharp</Product>
     <Company>SciSharp STACK</Company>
     <RootNamespace>NumSharp</RootNamespace>
-    <Version>0.20.5</Version>
+    <Version>0.30.0-alpha</Version>
     <Version Condition=" '$(VersionSuffix)' != '' ">$(Version)-$(VersionSuffix)</Version>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AssemblyOriginatorKeyFile>Open.snk</AssemblyOriginatorKeyFile>
@@ -32,6 +33,7 @@
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <DelaySign>false</DelaySign>
     <Configurations>Debug;Release;Publish;Debug-Minimal</Configurations>
+    <SignAssembly>true</SignAssembly>
   </PropertyGroup>
 
   <PropertyGroup Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('$(TargetFramework)', '^net\d'))">
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Boolean.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Boolean.cs
index 0f81f4159..3a8e55dd9 100644
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Boolean.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Boolean.cs
@@ -19,7 +19,7 @@ public unsafe NDArray<bool> EqualsBoolean(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of bool
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "=="
                 case NPTypeCode.Boolean:
                 {
@@ -119,50 +119,6 @@ public unsafe NDArray<bool> EqualsBoolean(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((bool*)lhs.Address) ? 1 : 0) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((bool*)lhs.Address) ? 1 : 0) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int32:
                 {
                     //if return type is scalar
@@ -185,28 +141,6 @@ public unsafe NDArray<bool> EqualsBoolean(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((bool*)lhs.Address) ? 1 : 0) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int64:
                 {
                     //if return type is scalar
@@ -229,72 +163,6 @@ public unsafe NDArray<bool> EqualsBoolean(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((bool*)lhs.Address) ? 1ul : 0ul) == *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1ul : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((bool*)lhs.Address) ? 1 : 0) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((bool*)lhs.Address) ? 1 : 0) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Single:
                 {
                     //if return type is scalar
@@ -317,14 +185,14 @@ public unsafe NDArray<bool> EqualsBoolean(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((bool*)lhs.Address) ? 1 : 0) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>(((*((bool*)lhs.Address) ? 1 : 0) == *((double*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (bool*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (double*)rhs.Address;
                     var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
                     Shape retShape = ret.Shape;
                     
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Byte.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Byte.cs
index 1bc4833d7..2c6111e64 100644
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Byte.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Byte.cs
@@ -19,7 +19,7 @@ public unsafe NDArray<bool> EqualsByte(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of byte
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "=="
                 %op_bool = "=="
                 case NPTypeCode.Boolean:
@@ -120,50 +120,6 @@ public unsafe NDArray<bool> EqualsByte(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((byte*)lhs.Address) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (byte) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((byte*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (byte) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int32:
                 {
                     //if return type is scalar
@@ -186,28 +142,6 @@ public unsafe NDArray<bool> EqualsByte(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((byte*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (byte) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int64:
                 {
                     //if return type is scalar
@@ -230,72 +164,6 @@ public unsafe NDArray<bool> EqualsByte(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((byte*)lhs.Address) == *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (byte) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((byte*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (byte) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((byte*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (byte) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Single:
                 {
                     //if return type is scalar
@@ -318,14 +186,14 @@ public unsafe NDArray<bool> EqualsByte(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((byte*)lhs.Address) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>((*((byte*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (byte*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (double*)rhs.Address;
                     var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
                     Shape retShape = ret.Shape;
                     
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Char.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Char.cs
deleted file mode 100644
index 7b3f61499..000000000
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Char.cs
+++ /dev/null
@@ -1,349 +0,0 @@
-//Generated by Regex Templating Engine at 21/07/2019 23:20:20 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Operations\Elementwise\Templates\Default.Op.Equals.template.cs
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using NumSharp.Generic;
-using NumSharp.Utilities;
-
-namespace NumSharp.Backends
-{
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray<bool> EqualsChar(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of char
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "=="
-                %op_bool = "=="
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) %(op) (*((bool*)rhs.Address) ? (char) 1 : (char) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) %(op_bool) 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-	            %foreach except(supported_dtypes, "Boolean"), except(supported_dtypes_lowercase, "bool")%
-                case NPTypeCode.#1:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) #(op) *((#2*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) #(op) (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == (*((bool*)rhs.Address) ? (char) 1 : (char) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) == 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Byte:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((byte*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((int*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((long*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((float*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Decimal:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((char*)lhs.Address) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (char*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (char) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Decimal.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Decimal.cs
deleted file mode 100644
index 8599d604e..000000000
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Decimal.cs
+++ /dev/null
@@ -1,349 +0,0 @@
-//Generated by Regex Templating Engine at 21/07/2019 23:20:20 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Operations\Elementwise\Templates\Default.Op.Equals.template.cs
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using NumSharp.Generic;
-using NumSharp.Utilities;
-
-namespace NumSharp.Backends
-{
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray<bool> EqualsDecimal(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of decimal
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "=="
-                %op_bool = "=="
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) %(op) (*((bool*)rhs.Address) ? (decimal) 1 : (decimal) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) %(op_bool) 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-	            %foreach except(supported_dtypes, "Boolean"), except(supported_dtypes_lowercase, "bool")%
-                case NPTypeCode.#1:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) #(op) *((#2*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) #(op) (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == (*((bool*)rhs.Address) ? (decimal) 1 : (decimal) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) == 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Byte:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == *((byte*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == *((int*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == *((long*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == (decimal) *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == (decimal) *((float*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Decimal:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((decimal*)lhs.Address) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (decimal*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (decimal) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Double.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Double.cs
index ad7f4e60e..2184a8218 100644
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Double.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Double.cs
@@ -19,7 +19,7 @@ public unsafe NDArray<bool> EqualsDouble(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of double
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "=="
                 %op_bool = "=="
                 case NPTypeCode.Boolean:
@@ -120,50 +120,6 @@ public unsafe NDArray<bool> EqualsDouble(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((double*)lhs.Address) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (double) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((double*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (double) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int32:
                 {
                     //if return type is scalar
@@ -186,28 +142,6 @@ public unsafe NDArray<bool> EqualsDouble(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((double*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (double) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int64:
                 {
                     //if return type is scalar
@@ -230,72 +164,6 @@ public unsafe NDArray<bool> EqualsDouble(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((double*)lhs.Address) == *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (double) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((double*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (double) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((double*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (double) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Single:
                 {
                     //if return type is scalar
@@ -318,14 +186,14 @@ public unsafe NDArray<bool> EqualsDouble(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((double*)lhs.Address) == (double) *((decimal*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>((*((double*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (double*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (double*)rhs.Address;
                     var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
                     Shape retShape = ret.Shape;
                     
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int16.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int16.cs
deleted file mode 100644
index c506456eb..000000000
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int16.cs
+++ /dev/null
@@ -1,349 +0,0 @@
-//Generated by Regex Templating Engine at 21/07/2019 23:20:20 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Operations\Elementwise\Templates\Default.Op.Equals.template.cs
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using NumSharp.Generic;
-using NumSharp.Utilities;
-
-namespace NumSharp.Backends
-{
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray<bool> EqualsInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of short
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "=="
-                %op_bool = "=="
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) %(op) (*((bool*)rhs.Address) ? (short) 1 : (short) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) %(op_bool) 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-	            %foreach except(supported_dtypes, "Boolean"), except(supported_dtypes_lowercase, "bool")%
-                case NPTypeCode.#1:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) #(op) *((#2*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) #(op) (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == (*((bool*)rhs.Address) ? (short) 1 : (short) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) == 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Byte:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == *((byte*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == *((int*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == *((long*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == (int) *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == *((float*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Decimal:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((short*)lhs.Address) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (short*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (short) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int32.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int32.cs
index 77fcbacc5..833b1922a 100644
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int32.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int32.cs
@@ -19,7 +19,7 @@ public unsafe NDArray<bool> EqualsInt32(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of int
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "=="
                 %op_bool = "=="
                 case NPTypeCode.Boolean:
@@ -120,50 +120,6 @@ public unsafe NDArray<bool> EqualsInt32(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((int*)lhs.Address) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (int) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((int*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (int) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int32:
                 {
                     //if return type is scalar
@@ -186,28 +142,6 @@ public unsafe NDArray<bool> EqualsInt32(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((int*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (int) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int64:
                 {
                     //if return type is scalar
@@ -230,72 +164,6 @@ public unsafe NDArray<bool> EqualsInt32(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((int*)lhs.Address) == (int) *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (int) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((int*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (int) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((int*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (int) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Single:
                 {
                     //if return type is scalar
@@ -318,14 +186,14 @@ public unsafe NDArray<bool> EqualsInt32(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((int*)lhs.Address) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>((*((int*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (int*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (double*)rhs.Address;
                     var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
                     Shape retShape = ret.Shape;
                     
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int64.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int64.cs
index 0dbd06d99..9695d03cf 100644
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int64.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Int64.cs
@@ -19,7 +19,7 @@ public unsafe NDArray<bool> EqualsInt64(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of long
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "=="
                 %op_bool = "=="
                 case NPTypeCode.Boolean:
@@ -120,50 +120,6 @@ public unsafe NDArray<bool> EqualsInt64(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((long*)lhs.Address) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (long) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((long*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (long) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int32:
                 {
                     //if return type is scalar
@@ -186,28 +142,6 @@ public unsafe NDArray<bool> EqualsInt64(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((long*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (long) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int64:
                 {
                     //if return type is scalar
@@ -230,72 +164,6 @@ public unsafe NDArray<bool> EqualsInt64(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((long*)lhs.Address) == (long) *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (long) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((long*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (long) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((long*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (long) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Single:
                 {
                     //if return type is scalar
@@ -318,14 +186,14 @@ public unsafe NDArray<bool> EqualsInt64(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((long*)lhs.Address) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>((*((long*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (long*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (double*)rhs.Address;
                     var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
                     Shape retShape = ret.Shape;
                     
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Single.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Single.cs
index 9ad9e25c1..a011c714a 100644
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Single.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.Single.cs
@@ -19,7 +19,7 @@ public unsafe NDArray<bool> EqualsSingle(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of float
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "=="
                 %op_bool = "=="
                 case NPTypeCode.Boolean:
@@ -120,50 +120,6 @@ public unsafe NDArray<bool> EqualsSingle(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((float*)lhs.Address) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (float) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((float*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (float) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int32:
                 {
                     //if return type is scalar
@@ -186,28 +142,6 @@ public unsafe NDArray<bool> EqualsSingle(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((float*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (float) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Int64:
                 {
                     //if return type is scalar
@@ -230,72 +164,6 @@ public unsafe NDArray<bool> EqualsSingle(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((float*)lhs.Address) == *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (float) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((float*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (float) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((float*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (float) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
                 case NPTypeCode.Single:
                 {
                     //if return type is scalar
@@ -318,14 +186,14 @@ public unsafe NDArray<bool> EqualsSingle(in NDArray lhs, in NDArray rhs)
                     return ret;
                 }
 
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((float*)lhs.Address) == (double) *((decimal*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>((*((float*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (float*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (double*)rhs.Address;
                     var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
                     Shape retShape = ret.Shape;
                     
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.UInt16.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.UInt16.cs
deleted file mode 100644
index dd17313d8..000000000
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.UInt16.cs
+++ /dev/null
@@ -1,349 +0,0 @@
-//Generated by Regex Templating Engine at 21/07/2019 23:20:20 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Operations\Elementwise\Templates\Default.Op.Equals.template.cs
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using NumSharp.Generic;
-using NumSharp.Utilities;
-
-namespace NumSharp.Backends
-{
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray<bool> EqualsUInt16(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ushort
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "=="
-                %op_bool = "=="
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) %(op) (*((bool*)rhs.Address) ? (ushort) 1 : (ushort) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) %(op_bool) 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-	            %foreach except(supported_dtypes, "Boolean"), except(supported_dtypes_lowercase, "bool")%
-                case NPTypeCode.#1:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) #(op) *((#2*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) #(op) (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == (*((bool*)rhs.Address) ? (ushort) 1 : (ushort) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) == 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Byte:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((byte*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((int*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((long*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((float*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Decimal:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ushort*)lhs.Address) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ushort*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ushort) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.UInt32.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.UInt32.cs
deleted file mode 100644
index df6bd33fb..000000000
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.UInt32.cs
+++ /dev/null
@@ -1,349 +0,0 @@
-//Generated by Regex Templating Engine at 21/07/2019 23:20:20 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Operations\Elementwise\Templates\Default.Op.Equals.template.cs
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using NumSharp.Generic;
-using NumSharp.Utilities;
-
-namespace NumSharp.Backends
-{
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray<bool> EqualsUInt32(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of uint
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "=="
-                %op_bool = "=="
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) %(op) (*((bool*)rhs.Address) ? (uint) 1 : (uint) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) %(op_bool) 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-	            %foreach except(supported_dtypes, "Boolean"), except(supported_dtypes_lowercase, "bool")%
-                case NPTypeCode.#1:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) #(op) *((#2*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) #(op) (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == (*((bool*)rhs.Address) ? (uint) 1 : (uint) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) == 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Byte:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((byte*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((int*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((long*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((float*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Decimal:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((uint*)lhs.Address) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (uint*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (uint) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.UInt64.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.UInt64.cs
deleted file mode 100644
index 4ce031668..000000000
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.UInt64.cs
+++ /dev/null
@@ -1,349 +0,0 @@
-//Generated by Regex Templating Engine at 21/07/2019 23:20:20 UTC
-//template source: C:\Users\Eli-PC\Desktop\SciSharp\NumSharp\src\NumSharp.Core\Operations\Elementwise\Templates\Default.Op.Equals.template.cs
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using NumSharp.Generic;
-using NumSharp.Utilities;
-
-namespace NumSharp.Backends
-{
-    public partial class DefaultEngine
-    {
-        [MethodImpl((MethodImplOptions)768)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
-        public unsafe NDArray<bool> EqualsUInt64(in NDArray lhs, in NDArray rhs)
-        {
-            //lhs is NDArray of ulong
-            switch (rhs.GetTypeCode)
-            {
-#if _REGEN
-                %op = "=="
-                %op_bool = "=="
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) %(op) (*((bool*)rhs.Address) ? (ulong) 1 : (ulong) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) %(op_bool) 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-	            %foreach except(supported_dtypes, "Boolean"), except(supported_dtypes_lowercase, "bool")%
-                case NPTypeCode.#1:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) #(op) *((#2*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (#2*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) #(op) (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                %
-                default:
-		            throw new NotSupportedException();
-#else
-
-                case NPTypeCode.Boolean:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == (*((bool*)rhs.Address) ? (ulong) 1 : (ulong) 0))).MakeGeneric<bool>();;
-
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (bool*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-                    //iterate
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) == 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Byte:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == *((byte*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (byte*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == (ulong) *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == (ulong) *((int*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (int*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == (ulong) *((long*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (long*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Single:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == *((float*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (float*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Decimal:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>((*((ulong*)lhs.Address) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (ulong*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (ulong) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                default:
-		            throw new NotSupportedException();
-#endif
-            }
-        }
-    }
-}
diff --git a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.cs b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.cs
index 3f65ec2a9..ba2fd7458 100644
--- a/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/Equals/Default.Equals.cs
@@ -13,7 +13,7 @@ public override NDArray<bool> Compare(in NDArray x, in NDArray y)
         {
             switch (x.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
 	            %foreach supported_dtypes,supported_dtypes_lowercase%
 	            case NPTypeCode.#1: return Equals#1(x,y);
 	            %
@@ -22,16 +22,10 @@ public override NDArray<bool> Compare(in NDArray x, in NDArray y)
 #else
 	            case NPTypeCode.Boolean: return EqualsBoolean(x,y);
 	            case NPTypeCode.Byte: return EqualsByte(x,y);
-	            case NPTypeCode.Int16: return EqualsInt16(x,y);
-	            case NPTypeCode.UInt16: return EqualsUInt16(x,y);
 	            case NPTypeCode.Int32: return EqualsInt32(x,y);
-	            case NPTypeCode.UInt32: return EqualsUInt32(x,y);
 	            case NPTypeCode.Int64: return EqualsInt64(x,y);
-	            case NPTypeCode.UInt64: return EqualsUInt64(x,y);
-	            case NPTypeCode.Char: return EqualsChar(x,y);
-	            case NPTypeCode.Double: return EqualsDouble(x,y);
 	            case NPTypeCode.Single: return EqualsSingle(x,y);
-	            case NPTypeCode.Decimal: return EqualsDecimal(x,y);
+	            case NPTypeCode.Double: return EqualsDouble(x,y);
 	            default:
 		            throw new NotSupportedException();
 #endif
diff --git a/src/NumSharp.Core/Operations/Elementwise/NDArray.Greater.cs b/src/NumSharp.Core/Operations/Elementwise/NDArray.Greater.cs
index 078c5fa69..93e54589c 100644
--- a/src/NumSharp.Core/Operations/Elementwise/NDArray.Greater.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/NDArray.Greater.cs
@@ -1,7 +1,220 @@
-namespace NumSharp
+using System;
+using NumSharp.Backends;
+using NumSharp.Generic;
+using NumSharp.Utilities;
+
+namespace NumSharp
 {
     public partial class NDArray
     {
+        public static unsafe NumSharp.Generic.NDArray<bool> operator >(NDArray lhs, NDArray rhs)
+        {
+#if _REGEN1
+            if(lhs.typecode != rhs.typecode)
+            {
+                throw new NotImplementedException("please make sure operands have the same data type");
+            }
+            else if (lhs.typecode == NPTypeCode.Boolean)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar<bool>((*(bool*)lhs.Address ? 1 : 0) > (*(bool*)rhs.Address ? 1 : 0)).MakeGeneric<bool>();
+
+                (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (bool*)lhs.Address;
+                var rhs_address = (bool*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) > (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+            %op = ">"
+	        %foreach except(supported_dtypes, "Boolean"), except(supported_dtypes_lowercase, "bool")%
+            else if (lhs.typecode == NPTypeCode.#1)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar<bool>(*(#2*)lhs.Address #(op) *(#2*)rhs.Address).MakeGeneric<bool>();
+
+                (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (#2*)lhs.Address;
+                var rhs_address = (#2*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) #(op) *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            %
+            else
+            {
+                throw new NotImplementedException($"{lhs.typecode} > {rhs.typecode}");
+            }
+#else
+            if(lhs.typecode != rhs.typecode)
+            {
+                throw new NotImplementedException("please make sure operands have the same data type");
+            }
+            else if (lhs.typecode == NPTypeCode.Boolean)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar<bool>((*(bool*)lhs.Address ? 1 : 0) > (*(bool*)rhs.Address ? 1 : 0)).MakeGeneric<bool>();
+
+                (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (bool*)lhs.Address;
+                var rhs_address = (bool*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) > (*(rhs_address + BroadcastedRightShape.GetOffset(current)) ? 1 : 0);
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+            else if (lhs.typecode == NPTypeCode.Byte)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar<bool>(*(byte*)lhs.Address > *(byte*)rhs.Address).MakeGeneric<bool>();
+
+                (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (byte*)lhs.Address;
+                var rhs_address = (byte*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) > *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Int32)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar<bool>(*(int*)lhs.Address > *(int*)rhs.Address).MakeGeneric<bool>();
+
+                (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (int*)lhs.Address;
+                var rhs_address = (int*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) > *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Int64)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar<bool>(*(long*)lhs.Address > *(long*)rhs.Address).MakeGeneric<bool>();
+
+                (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (long*)lhs.Address;
+                var rhs_address = (long*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) > *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Single)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar<bool>(*(float*)lhs.Address > *(float*)rhs.Address).MakeGeneric<bool>();
+
+                (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (float*)lhs.Address;
+                var rhs_address = (float*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) > *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else if (lhs.typecode == NPTypeCode.Double)
+            {
+                if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                    return NDArray.Scalar<bool>(*(double*)lhs.Address > *(double*)rhs.Address).MakeGeneric<bool>();
+
+                (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                var lhs_address = (double*)lhs.Address;
+                var rhs_address = (double*)rhs.Address;
+                var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                Shape retShape = ret.Shape;
+
+                //iterate
+                var ret_address = (bool*)ret.Address;
+                var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                int[] current = incr.Index;
+                do
+                {
+                    *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) > *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                } while (incr.Next() != null);
+
+                return ret;
+            }
+
+            else
+            {
+                throw new NotImplementedException($"{lhs.typecode} > {rhs.typecode}");
+            }
+#endif
+        }
+
         public static NumSharp.Generic.NDArray<bool> operator >(NDArray np, int obj)
         {
             return (np > (System.Object)obj);
diff --git a/src/NumSharp.Core/Operations/Elementwise/NDArray.Lower.cs b/src/NumSharp.Core/Operations/Elementwise/NDArray.Lower.cs
index 015ce6ac5..335b1a568 100644
--- a/src/NumSharp.Core/Operations/Elementwise/NDArray.Lower.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/NDArray.Lower.cs
@@ -2,6 +2,11 @@
 {
     public partial class NDArray
     {
+        public static NumSharp.Generic.NDArray<bool> operator <(NDArray lhs, NDArray rhs)
+        {
+            return rhs > lhs;
+        }
+
         public static NumSharp.Generic.NDArray<bool> operator <(NDArray np, int obj)
         {
             return (np < (System.Object)obj);
diff --git a/src/NumSharp.Core/Operations/Elementwise/NDArray.NOT.cs b/src/NumSharp.Core/Operations/Elementwise/NDArray.NOT.cs
index 0296f5ae7..9801d4e93 100644
--- a/src/NumSharp.Core/Operations/Elementwise/NDArray.NOT.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/NDArray.NOT.cs
@@ -11,7 +11,7 @@ public partial class NDArray
             var result = new NDArray(typeof(bool), self.shape);
             switch (self.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 case NPTypeCode.Boolean: 
                 {
                     var from = (bool*)self.Address;
@@ -57,28 +57,6 @@ public partial class NDArray
                     var from = (byte*)self.Address;
                     var to = (bool*)result.Address;
 
-                    var len = result.size;
-                    for (int i = 0; i < len; i++)
-                        *(to + i) = *(from + i) == 0; //if val is 0 then write true
-
-                    return result.MakeGeneric<bool>();
-                }
-	            case NPTypeCode.Int16: 
-                {
-                    var from = (short*)self.Address;
-                    var to = (bool*)result.Address;
-
-                    var len = result.size;
-                    for (int i = 0; i < len; i++)
-                        *(to + i) = *(from + i) == 0; //if val is 0 then write true
-
-                    return result.MakeGeneric<bool>();
-                }
-	            case NPTypeCode.UInt16: 
-                {
-                    var from = (ushort*)self.Address;
-                    var to = (bool*)result.Address;
-
                     var len = result.size;
                     for (int i = 0; i < len; i++)
                         *(to + i) = *(from + i) == 0; //if val is 0 then write true
@@ -90,17 +68,6 @@ public partial class NDArray
                     var from = (int*)self.Address;
                     var to = (bool*)result.Address;
 
-                    var len = result.size;
-                    for (int i = 0; i < len; i++)
-                        *(to + i) = *(from + i) == 0; //if val is 0 then write true
-
-                    return result.MakeGeneric<bool>();
-                }
-	            case NPTypeCode.UInt32: 
-                {
-                    var from = (uint*)self.Address;
-                    var to = (bool*)result.Address;
-
                     var len = result.size;
                     for (int i = 0; i < len; i++)
                         *(to + i) = *(from + i) == 0; //if val is 0 then write true
@@ -112,39 +79,6 @@ public partial class NDArray
                     var from = (long*)self.Address;
                     var to = (bool*)result.Address;
 
-                    var len = result.size;
-                    for (int i = 0; i < len; i++)
-                        *(to + i) = *(from + i) == 0; //if val is 0 then write true
-
-                    return result.MakeGeneric<bool>();
-                }
-	            case NPTypeCode.UInt64: 
-                {
-                    var from = (ulong*)self.Address;
-                    var to = (bool*)result.Address;
-
-                    var len = result.size;
-                    for (int i = 0; i < len; i++)
-                        *(to + i) = *(from + i) == 0; //if val is 0 then write true
-
-                    return result.MakeGeneric<bool>();
-                }
-	            case NPTypeCode.Char: 
-                {
-                    var from = (char*)self.Address;
-                    var to = (bool*)result.Address;
-
-                    var len = result.size;
-                    for (int i = 0; i < len; i++)
-                        *(to + i) = *(from + i) == 0; //if val is 0 then write true
-
-                    return result.MakeGeneric<bool>();
-                }
-	            case NPTypeCode.Double: 
-                {
-                    var from = (double*)self.Address;
-                    var to = (bool*)result.Address;
-
                     var len = result.size;
                     for (int i = 0; i < len; i++)
                         *(to + i) = *(from + i) == 0; //if val is 0 then write true
@@ -162,9 +96,9 @@ public partial class NDArray
 
                     return result.MakeGeneric<bool>();
                 }
-	            case NPTypeCode.Decimal: 
+	            case NPTypeCode.Double: 
                 {
-                    var from = (decimal*)self.Address;
+                    var from = (double*)self.Address;
                     var to = (bool*)result.Address;
 
                     var len = result.size;
diff --git a/src/NumSharp.Core/Operations/Elementwise/NDArray.Primitive.cs b/src/NumSharp.Core/Operations/Elementwise/NDArray.Primitive.cs
index 77ba4b9b5..b8c9a2210 100644
--- a/src/NumSharp.Core/Operations/Elementwise/NDArray.Primitive.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/NDArray.Primitive.cs
@@ -11,7 +11,7 @@ public partial class NDArray
         public static NDArray operator +(NDArray x) => x.copy(); //to maintain immutability like numpy does.
 
 
-#if _REGEN
+#if _REGEN1
     %mod = "%"
 	%foreach supported_dtypes, supported_dtypes_lowercase%
 
@@ -53,30 +53,6 @@ public partial class NDArray
         public static NDArray operator %(byte left, NDArray right) => np.mod(Scalar(left), right);
         public static NDArray operator %(NDArray left, byte right) => np.mod(left, Scalar(right));
 
-        //short
-        public static NDArray operator +(short left, NDArray right) => np.add(Scalar(left), right);
-        public static NDArray operator +(NDArray left, short right) => np.add(left, Scalar(right));
-        public static NDArray operator -(short left, NDArray right) => np.subtract(Scalar(left), right);
-        public static NDArray operator -(NDArray left, short right) => np.subtract(left, Scalar(right));
-        public static NDArray operator *(short left, NDArray right) => np.multiply(Scalar(left), right);
-        public static NDArray operator *(NDArray left, short right) => np.multiply(left, Scalar(right));
-        public static NDArray operator /(short left, NDArray right) => np.divide(Scalar(left), right);
-        public static NDArray operator /(NDArray left, short right) => np.divide(left, Scalar(right));
-        public static NDArray operator %(short left, NDArray right) => np.mod(Scalar(left), right);
-        public static NDArray operator %(NDArray left, short right) => np.mod(left, Scalar(right));
-
-        //ushort
-        public static NDArray operator +(ushort left, NDArray right) => np.add(Scalar(left), right);
-        public static NDArray operator +(NDArray left, ushort right) => np.add(left, Scalar(right));
-        public static NDArray operator -(ushort left, NDArray right) => np.subtract(Scalar(left), right);
-        public static NDArray operator -(NDArray left, ushort right) => np.subtract(left, Scalar(right));
-        public static NDArray operator *(ushort left, NDArray right) => np.multiply(Scalar(left), right);
-        public static NDArray operator *(NDArray left, ushort right) => np.multiply(left, Scalar(right));
-        public static NDArray operator /(ushort left, NDArray right) => np.divide(Scalar(left), right);
-        public static NDArray operator /(NDArray left, ushort right) => np.divide(left, Scalar(right));
-        public static NDArray operator %(ushort left, NDArray right) => np.mod(Scalar(left), right);
-        public static NDArray operator %(NDArray left, ushort right) => np.mod(left, Scalar(right));
-
         //int
         public static NDArray operator +(int left, NDArray right) => np.add(Scalar(left), right);
         public static NDArray operator +(NDArray left, int right) => np.add(left, Scalar(right));
@@ -89,18 +65,6 @@ public partial class NDArray
         public static NDArray operator %(int left, NDArray right) => np.mod(Scalar(left), right);
         public static NDArray operator %(NDArray left, int right) => np.mod(left, Scalar(right));
 
-        //uint
-        public static NDArray operator +(uint left, NDArray right) => np.add(Scalar(left), right);
-        public static NDArray operator +(NDArray left, uint right) => np.add(left, Scalar(right));
-        public static NDArray operator -(uint left, NDArray right) => np.subtract(Scalar(left), right);
-        public static NDArray operator -(NDArray left, uint right) => np.subtract(left, Scalar(right));
-        public static NDArray operator *(uint left, NDArray right) => np.multiply(Scalar(left), right);
-        public static NDArray operator *(NDArray left, uint right) => np.multiply(left, Scalar(right));
-        public static NDArray operator /(uint left, NDArray right) => np.divide(Scalar(left), right);
-        public static NDArray operator /(NDArray left, uint right) => np.divide(left, Scalar(right));
-        public static NDArray operator %(uint left, NDArray right) => np.mod(Scalar(left), right);
-        public static NDArray operator %(NDArray left, uint right) => np.mod(left, Scalar(right));
-
         //long
         public static NDArray operator +(long left, NDArray right) => np.add(Scalar(left), right);
         public static NDArray operator +(NDArray left, long right) => np.add(left, Scalar(right));
@@ -113,42 +77,6 @@ public partial class NDArray
         public static NDArray operator %(long left, NDArray right) => np.mod(Scalar(left), right);
         public static NDArray operator %(NDArray left, long right) => np.mod(left, Scalar(right));
 
-        //ulong
-        public static NDArray operator +(ulong left, NDArray right) => np.add(Scalar(left), right);
-        public static NDArray operator +(NDArray left, ulong right) => np.add(left, Scalar(right));
-        public static NDArray operator -(ulong left, NDArray right) => np.subtract(Scalar(left), right);
-        public static NDArray operator -(NDArray left, ulong right) => np.subtract(left, Scalar(right));
-        public static NDArray operator *(ulong left, NDArray right) => np.multiply(Scalar(left), right);
-        public static NDArray operator *(NDArray left, ulong right) => np.multiply(left, Scalar(right));
-        public static NDArray operator /(ulong left, NDArray right) => np.divide(Scalar(left), right);
-        public static NDArray operator /(NDArray left, ulong right) => np.divide(left, Scalar(right));
-        public static NDArray operator %(ulong left, NDArray right) => np.mod(Scalar(left), right);
-        public static NDArray operator %(NDArray left, ulong right) => np.mod(left, Scalar(right));
-
-        //char
-        public static NDArray operator +(char left, NDArray right) => np.add(Scalar(left), right);
-        public static NDArray operator +(NDArray left, char right) => np.add(left, Scalar(right));
-        public static NDArray operator -(char left, NDArray right) => np.subtract(Scalar(left), right);
-        public static NDArray operator -(NDArray left, char right) => np.subtract(left, Scalar(right));
-        public static NDArray operator *(char left, NDArray right) => np.multiply(Scalar(left), right);
-        public static NDArray operator *(NDArray left, char right) => np.multiply(left, Scalar(right));
-        public static NDArray operator /(char left, NDArray right) => np.divide(Scalar(left), right);
-        public static NDArray operator /(NDArray left, char right) => np.divide(left, Scalar(right));
-        public static NDArray operator %(char left, NDArray right) => np.mod(Scalar(left), right);
-        public static NDArray operator %(NDArray left, char right) => np.mod(left, Scalar(right));
-
-        //double
-        public static NDArray operator +(double left, NDArray right) => np.add(Scalar(left), right);
-        public static NDArray operator +(NDArray left, double right) => np.add(left, Scalar(right));
-        public static NDArray operator -(double left, NDArray right) => np.subtract(Scalar(left), right);
-        public static NDArray operator -(NDArray left, double right) => np.subtract(left, Scalar(right));
-        public static NDArray operator *(double left, NDArray right) => np.multiply(Scalar(left), right);
-        public static NDArray operator *(NDArray left, double right) => np.multiply(left, Scalar(right));
-        public static NDArray operator /(double left, NDArray right) => np.divide(Scalar(left), right);
-        public static NDArray operator /(NDArray left, double right) => np.divide(left, Scalar(right));
-        public static NDArray operator %(double left, NDArray right) => np.mod(Scalar(left), right);
-        public static NDArray operator %(NDArray left, double right) => np.mod(left, Scalar(right));
-
         //float
         public static NDArray operator +(float left, NDArray right) => np.add(Scalar(left), right);
         public static NDArray operator +(NDArray left, float right) => np.add(left, Scalar(right));
@@ -161,17 +89,17 @@ public partial class NDArray
         public static NDArray operator %(float left, NDArray right) => np.mod(Scalar(left), right);
         public static NDArray operator %(NDArray left, float right) => np.mod(left, Scalar(right));
 
-        //decimal
-        public static NDArray operator +(decimal left, NDArray right) => np.add(Scalar(left), right);
-        public static NDArray operator +(NDArray left, decimal right) => np.add(left, Scalar(right));
-        public static NDArray operator -(decimal left, NDArray right) => np.subtract(Scalar(left), right);
-        public static NDArray operator -(NDArray left, decimal right) => np.subtract(left, Scalar(right));
-        public static NDArray operator *(decimal left, NDArray right) => np.multiply(Scalar(left), right);
-        public static NDArray operator *(NDArray left, decimal right) => np.multiply(left, Scalar(right));
-        public static NDArray operator /(decimal left, NDArray right) => np.divide(Scalar(left), right);
-        public static NDArray operator /(NDArray left, decimal right) => np.divide(left, Scalar(right));
-        public static NDArray operator %(decimal left, NDArray right) => np.mod(Scalar(left), right);
-        public static NDArray operator %(NDArray left, decimal right) => np.mod(left, Scalar(right));
+        //double
+        public static NDArray operator +(double left, NDArray right) => np.add(Scalar(left), right);
+        public static NDArray operator +(NDArray left, double right) => np.add(left, Scalar(right));
+        public static NDArray operator -(double left, NDArray right) => np.subtract(Scalar(left), right);
+        public static NDArray operator -(NDArray left, double right) => np.subtract(left, Scalar(right));
+        public static NDArray operator *(double left, NDArray right) => np.multiply(Scalar(left), right);
+        public static NDArray operator *(NDArray left, double right) => np.multiply(left, Scalar(right));
+        public static NDArray operator /(double left, NDArray right) => np.divide(Scalar(left), right);
+        public static NDArray operator /(NDArray left, double right) => np.divide(left, Scalar(right));
+        public static NDArray operator %(double left, NDArray right) => np.mod(Scalar(left), right);
+        public static NDArray operator %(NDArray left, double right) => np.mod(left, Scalar(right));
 #endif
 
 
diff --git a/src/NumSharp.Core/Operations/Elementwise/Templates/Default.Op.Boolean.template.cs b/src/NumSharp.Core/Operations/Elementwise/Templates/Default.Op.Boolean.template.cs
index dea35080a..f040705e0 100644
--- a/src/NumSharp.Core/Operations/Elementwise/Templates/Default.Op.Boolean.template.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/Templates/Default.Op.Boolean.template.cs
@@ -29,7 +29,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of __2__
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "=="
                 case NPTypeCode.Boolean:
                 {
@@ -101,7 +101,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
                     int[] current = incr.Index;
                     do
                     {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) == 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) == *(rhs_address + BroadcastedRightShape.GetOffset(current));
                     } while (incr.Next() != null);
 
                     return ret;
@@ -111,7 +111,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((byte*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address) ? 1 : 0) == *((byte*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (__2__*)lhs.Address;
                     var rhs_address = (byte*)rhs.Address;
@@ -123,51 +123,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
                     int[] current = incr.Index;
                     do
                     {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Int16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((short*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (__2__*)lhs.Address;
-                    var rhs_address = (short*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((ushort*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (__2__*)lhs.Address;
-                    var rhs_address = (ushort*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
                     } while (incr.Next() != null);
 
                     return ret;
@@ -177,7 +133,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((int*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address) ? 1 : 0) == *((int*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (__2__*)lhs.Address;
                     var rhs_address = (int*)rhs.Address;
@@ -189,29 +145,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
                     int[] current = incr.Index;
                     do
                     {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt32:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((uint*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (__2__*)lhs.Address;
-                    var rhs_address = (uint*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
                     } while (incr.Next() != null);
 
                     return ret;
@@ -221,7 +155,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((long*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address) ? 1 : 0) == *((long*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (__2__*)lhs.Address;
                     var rhs_address = (long*)rhs.Address;
@@ -233,73 +167,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
                     int[] current = incr.Index;
                     do
                     {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.UInt64:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((ulong*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (__2__*)lhs.Address;
-                    var rhs_address = (ulong*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Char:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((char*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (__2__*)lhs.Address;
-                    var rhs_address = (char*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
-                    } while (incr.Next() != null);
-
-                    return ret;
-                }
-
-                case NPTypeCode.Double:
-                {
-                    //if return type is scalar
-                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((double*)rhs.Address))).MakeGeneric<bool>();
-                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
-                    var lhs_address = (__2__*)lhs.Address;
-                    var rhs_address = (double*)rhs.Address;
-                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
-                    Shape retShape = ret.Shape;
-                    
-		            var ret_address = (bool*)ret.Address;
-                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
-                    int[] current = incr.Index;
-                    do
-                    {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
                     } while (incr.Next() != null);
 
                     return ret;
@@ -309,7 +177,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((float*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address) ? 1 : 0) == *((float*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (__2__*)lhs.Address;
                     var rhs_address = (float*)rhs.Address;
@@ -321,20 +189,20 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
                     int[] current = incr.Index;
                     do
                     {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
                     } while (incr.Next() != null);
 
                     return ret;
                 }
 
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
                     //if return type is scalar
                     if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
-                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address)  ? 1 : 0) == *((decimal*)rhs.Address))).MakeGeneric<bool>();
+                        return NDArray.Scalar<bool>(((*((__2__*)lhs.Address) ? 1 : 0) == *((double*)rhs.Address))).MakeGeneric<bool>();
                     (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
                     var lhs_address = (__2__*)lhs.Address;
-                    var rhs_address = (decimal*)rhs.Address;
+                    var rhs_address = (double*)rhs.Address;
                     var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
                     Shape retShape = ret.Shape;
                     
@@ -343,7 +211,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
                     int[] current = incr.Index;
                     do
                     {
-                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                        *(ret_address + retShape.GetOffset(current)) = ((*(lhs_address + BroadcastedLeftShape.GetOffset(current)) ? 1 : 0) == *(rhs_address + BroadcastedRightShape.GetOffset(current)));
                     } while (incr.Next() != null);
 
                     return ret;
diff --git a/src/NumSharp.Core/Operations/Elementwise/Templates/Default.Op.Equals.template.cs b/src/NumSharp.Core/Operations/Elementwise/Templates/Default.Op.Equals.template.cs
index 931699a47..1bf260dd9 100644
--- a/src/NumSharp.Core/Operations/Elementwise/Templates/Default.Op.Equals.template.cs
+++ b/src/NumSharp.Core/Operations/Elementwise/Templates/Default.Op.Equals.template.cs
@@ -28,7 +28,7 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
             //lhs is NDArray of __2__
             switch (rhs.GetTypeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %op = "=="
                 %op_bool = "=="
                 case NPTypeCode.Boolean:
@@ -83,6 +83,142 @@ public unsafe NDArray<bool> Equals__1__(in NDArray lhs, in NDArray rhs)
 		            throw new NotSupportedException();
 #else
 
+                case NPTypeCode.Boolean:
+                {
+                    //if return type is scalar
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar<bool>((*((__2__*)lhs.Address) == (*((bool*)rhs.Address) ? (__2__) 1 : (__2__) 0))).MakeGeneric<bool>();;
+
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (bool*)rhs.Address;
+                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                    Shape retShape = ret.Shape;
+                    
+                    //iterate
+		            var ret_address = (bool*)ret.Address;
+                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                    int[] current = incr.Index;
+                    do
+                    {
+                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current))) == 0 != *(rhs_address + BroadcastedRightShape.GetOffset(current));
+                    } while (incr.Next() != null);
+
+                    return ret;
+                }
+
+                case NPTypeCode.Byte:
+                {
+                    //if return type is scalar
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar<bool>((*((__2__*)lhs.Address) == *((byte*)rhs.Address))).MakeGeneric<bool>();
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (byte*)rhs.Address;
+                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                    Shape retShape = ret.Shape;
+                    
+		            var ret_address = (bool*)ret.Address;
+                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                    int[] current = incr.Index;
+                    do
+                    {
+                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                    } while (incr.Next() != null);
+
+                    return ret;
+                }
+
+                case NPTypeCode.Int32:
+                {
+                    //if return type is scalar
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar<bool>((*((__2__*)lhs.Address) == *((int*)rhs.Address))).MakeGeneric<bool>();
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (int*)rhs.Address;
+                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                    Shape retShape = ret.Shape;
+                    
+		            var ret_address = (bool*)ret.Address;
+                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                    int[] current = incr.Index;
+                    do
+                    {
+                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                    } while (incr.Next() != null);
+
+                    return ret;
+                }
+
+                case NPTypeCode.Int64:
+                {
+                    //if return type is scalar
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar<bool>((*((__2__*)lhs.Address) == *((long*)rhs.Address))).MakeGeneric<bool>();
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (long*)rhs.Address;
+                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                    Shape retShape = ret.Shape;
+                    
+		            var ret_address = (bool*)ret.Address;
+                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                    int[] current = incr.Index;
+                    do
+                    {
+                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                    } while (incr.Next() != null);
+
+                    return ret;
+                }
+
+                case NPTypeCode.Single:
+                {
+                    //if return type is scalar
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar<bool>((*((__2__*)lhs.Address) == *((float*)rhs.Address))).MakeGeneric<bool>();
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (float*)rhs.Address;
+                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                    Shape retShape = ret.Shape;
+                    
+		            var ret_address = (bool*)ret.Address;
+                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                    int[] current = incr.Index;
+                    do
+                    {
+                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                    } while (incr.Next() != null);
+
+                    return ret;
+                }
+
+                case NPTypeCode.Double:
+                {
+                    //if return type is scalar
+                    if (lhs.Shape.IsScalar && rhs.Shape.IsScalar)
+                        return NDArray.Scalar<bool>((*((__2__*)lhs.Address) == *((double*)rhs.Address))).MakeGeneric<bool>();
+                    (Shape BroadcastedLeftShape, Shape BroadcastedRightShape) = DefaultEngine.Broadcast(lhs.Shape, rhs.Shape);
+                    var lhs_address = (__2__*)lhs.Address;
+                    var rhs_address = (double*)rhs.Address;
+                    var ret = new NDArray<bool>(new Shape(BroadcastedLeftShape.dimensions), true);
+                    Shape retShape = ret.Shape;
+                    
+		            var ret_address = (bool*)ret.Address;
+                    var incr = new NDCoordinatesIncrementor(BroadcastedLeftShape.dimensions); //doesn't matter which side it is.
+                    int[] current = incr.Index;
+                    do
+                    {
+                        *(ret_address + retShape.GetOffset(current)) = (*(lhs_address + BroadcastedLeftShape.GetOffset(current)) == (__2__) *(rhs_address + BroadcastedRightShape.GetOffset(current)));
+                    } while (incr.Next() != null);
+
+                    return ret;
+                }
+
+                default:
+		            throw new NotSupportedException();
 #endif
             }
         }
diff --git a/src/NumSharp.Core/RandomSampling/np.random.randint.cs b/src/NumSharp.Core/RandomSampling/np.random.randint.cs
index 0b744023d..1d94795ee 100644
--- a/src/NumSharp.Core/RandomSampling/np.random.randint.cs
+++ b/src/NumSharp.Core/RandomSampling/np.random.randint.cs
@@ -32,7 +32,7 @@ public NDArray randint(long low, long high = -1, Shape size = default, Type dtyp
             var nd = new NDArray(dtype, size); //allocation called inside.
             switch (typecode)
             {
-#if _REGEN
+#if _REGEN1
                 %foreach supported_numericals,supported_numericals_lowercase%
                 case NPTypeCode.#1:
                 {
@@ -52,22 +52,6 @@ public NDArray randint(long low, long high = -1, Shape size = default, Type dtyp
                     
                     break;
                 }
-                case NPTypeCode.Int16:
-                {
-                    var data = (ArraySlice<short>)nd.Array;
-                    for (int i = 0; i < data.Count; i++)
-                        data[i] = Converts.ToInt16(randomizer.NextLong(low, high));
-                    
-                    break;
-                }
-                case NPTypeCode.UInt16:
-                {
-                    var data = (ArraySlice<ushort>)nd.Array;
-                    for (int i = 0; i < data.Count; i++)
-                        data[i] = Converts.ToUInt16(randomizer.NextLong(low, high));
-                    
-                    break;
-                }
                 case NPTypeCode.Int32:
                 {
                     var data = (ArraySlice<int>)nd.Array;
@@ -76,14 +60,6 @@ public NDArray randint(long low, long high = -1, Shape size = default, Type dtyp
                     
                     break;
                 }
-                case NPTypeCode.UInt32:
-                {
-                    var data = (ArraySlice<uint>)nd.Array;
-                    for (int i = 0; i < data.Count; i++)
-                        data[i] = Converts.ToUInt32(randomizer.NextLong(low, high));
-                    
-                    break;
-                }
                 case NPTypeCode.Int64:
                 {
                     var data = (ArraySlice<long>)nd.Array;
@@ -92,30 +68,6 @@ public NDArray randint(long low, long high = -1, Shape size = default, Type dtyp
                     
                     break;
                 }
-                case NPTypeCode.UInt64:
-                {
-                    var data = (ArraySlice<ulong>)nd.Array;
-                    for (int i = 0; i < data.Count; i++)
-                        data[i] = Converts.ToUInt64(randomizer.NextLong(low, high));
-                    
-                    break;
-                }
-                case NPTypeCode.Char:
-                {
-                    var data = (ArraySlice<char>)nd.Array;
-                    for (int i = 0; i < data.Count; i++)
-                        data[i] = Converts.ToChar(randomizer.NextLong(low, high));
-                    
-                    break;
-                }
-                case NPTypeCode.Double:
-                {
-                    var data = (ArraySlice<double>)nd.Array;
-                    for (int i = 0; i < data.Count; i++)
-                        data[i] = Converts.ToDouble(randomizer.NextLong(low, high));
-                    
-                    break;
-                }
                 case NPTypeCode.Single:
                 {
                     var data = (ArraySlice<float>)nd.Array;
@@ -124,11 +76,11 @@ public NDArray randint(long low, long high = -1, Shape size = default, Type dtyp
                     
                     break;
                 }
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
-                    var data = (ArraySlice<decimal>)nd.Array;
+                    var data = (ArraySlice<double>)nd.Array;
                     for (int i = 0; i < data.Count; i++)
-                        data[i] = Converts.ToDecimal(randomizer.NextLong(low, high));
+                        data[i] = Converts.ToDouble(randomizer.NextLong(low, high));
                     
                     break;
                 }
diff --git a/src/NumSharp.Core/RandomSampling/np.random.shuffle.cs b/src/NumSharp.Core/RandomSampling/np.random.shuffle.cs
index dad2a6803..178b26d21 100644
--- a/src/NumSharp.Core/RandomSampling/np.random.shuffle.cs
+++ b/src/NumSharp.Core/RandomSampling/np.random.shuffle.cs
@@ -20,7 +20,7 @@ public void shuffle(NDArray x, int passes = 2)
             Func<int, int> transformOffset = x.Shape.TransformOffset;
             unsafe
             {
-#if _REGEN
+#if _REGEN1
                 #region Compute
 		        switch (x.typecode)
 		        {
@@ -48,12 +48,11 @@ public void shuffle(NDArray x, int passes = 2)
 #else
 
                 #region Compute
-
-                switch (x.typecode)
-                {
-                    case NPTypeCode.Boolean:
-                    {
-                        var addr = (bool*)x.Address;
+		        switch (x.typecode)
+		        {
+			        case NPTypeCode.Boolean:
+			        {
+				        var addr = (bool*)x.Address;
                         var addr_index0 = addr + transformOffset(0);
                         bool tmp; //index 0
                         bool* addr_swap;
@@ -64,13 +63,11 @@ public void shuffle(NDArray x, int passes = 2)
                             *addr_index0 = *addr_swap;
                             *addr_swap = tmp;
                         }
-
                         break;
-                    }
-
-                    case NPTypeCode.Byte:
-                    {
-                        var addr = (byte*)x.Address;
+			        }
+			        case NPTypeCode.Byte:
+			        {
+				        var addr = (byte*)x.Address;
                         var addr_index0 = addr + transformOffset(0);
                         byte tmp; //index 0
                         byte* addr_swap;
@@ -81,47 +78,11 @@ public void shuffle(NDArray x, int passes = 2)
                             *addr_index0 = *addr_swap;
                             *addr_swap = tmp;
                         }
-
-                        break;
-                    }
-
-                    case NPTypeCode.Int16:
-                    {
-                        var addr = (short*)x.Address;
-                        var addr_index0 = addr + transformOffset(0);
-                        short tmp; //index 0
-                        short* addr_swap;
-                        while (count-- > 1)
-                        {
-                            tmp = *addr_index0;
-                            addr_swap = addr + transformOffset(randomizer.Next(size));
-                            *addr_index0 = *addr_swap;
-                            *addr_swap = tmp;
-                        }
-
                         break;
-                    }
-
-                    case NPTypeCode.UInt16:
-                    {
-                        var addr = (ushort*)x.Address;
-                        var addr_index0 = addr + transformOffset(0);
-                        ushort tmp; //index 0
-                        ushort* addr_swap;
-                        while (count-- > 1)
-                        {
-                            tmp = *addr_index0;
-                            addr_swap = addr + transformOffset(randomizer.Next(size));
-                            *addr_index0 = *addr_swap;
-                            *addr_swap = tmp;
-                        }
-
-                        break;
-                    }
-
-                    case NPTypeCode.Int32:
-                    {
-                        var addr = (int*)x.Address;
+			        }
+			        case NPTypeCode.Int32:
+			        {
+				        var addr = (int*)x.Address;
                         var addr_index0 = addr + transformOffset(0);
                         int tmp; //index 0
                         int* addr_swap;
@@ -132,30 +93,11 @@ public void shuffle(NDArray x, int passes = 2)
                             *addr_index0 = *addr_swap;
                             *addr_swap = tmp;
                         }
-
                         break;
-                    }
-
-                    case NPTypeCode.UInt32:
-                    {
-                        var addr = (uint*)x.Address;
-                        var addr_index0 = addr + transformOffset(0);
-                        uint tmp; //index 0
-                        uint* addr_swap;
-                        while (count-- > 1)
-                        {
-                            tmp = *addr_index0;
-                            addr_swap = addr + transformOffset(randomizer.Next(size));
-                            *addr_index0 = *addr_swap;
-                            *addr_swap = tmp;
-                        }
-
-                        break;
-                    }
-
-                    case NPTypeCode.Int64:
-                    {
-                        var addr = (long*)x.Address;
+			        }
+			        case NPTypeCode.Int64:
+			        {
+				        var addr = (long*)x.Address;
                         var addr_index0 = addr + transformOffset(0);
                         long tmp; //index 0
                         long* addr_swap;
@@ -166,64 +108,11 @@ public void shuffle(NDArray x, int passes = 2)
                             *addr_index0 = *addr_swap;
                             *addr_swap = tmp;
                         }
-
-                        break;
-                    }
-
-                    case NPTypeCode.UInt64:
-                    {
-                        var addr = (ulong*)x.Address;
-                        var addr_index0 = addr + transformOffset(0);
-                        ulong tmp; //index 0
-                        ulong* addr_swap;
-                        while (count-- > 1)
-                        {
-                            tmp = *addr_index0;
-                            addr_swap = addr + transformOffset(randomizer.Next(size));
-                            *addr_index0 = *addr_swap;
-                            *addr_swap = tmp;
-                        }
-
-                        break;
-                    }
-
-                    case NPTypeCode.Char:
-                    {
-                        var addr = (char*)x.Address;
-                        var addr_index0 = addr + transformOffset(0);
-                        char tmp; //index 0
-                        char* addr_swap;
-                        while (count-- > 1)
-                        {
-                            tmp = *addr_index0;
-                            addr_swap = addr + transformOffset(randomizer.Next(size));
-                            *addr_index0 = *addr_swap;
-                            *addr_swap = tmp;
-                        }
-
                         break;
-                    }
-
-                    case NPTypeCode.Double:
-                    {
-                        var addr = (double*)x.Address;
-                        var addr_index0 = addr + transformOffset(0);
-                        double tmp; //index 0
-                        double* addr_swap;
-                        while (count-- > 1)
-                        {
-                            tmp = *addr_index0;
-                            addr_swap = addr + transformOffset(randomizer.Next(size));
-                            *addr_index0 = *addr_swap;
-                            *addr_swap = tmp;
-                        }
-
-                        break;
-                    }
-
-                    case NPTypeCode.Single:
-                    {
-                        var addr = (float*)x.Address;
+			        }
+			        case NPTypeCode.Single:
+			        {
+				        var addr = (float*)x.Address;
                         var addr_index0 = addr + transformOffset(0);
                         float tmp; //index 0
                         float* addr_swap;
@@ -234,16 +123,14 @@ public void shuffle(NDArray x, int passes = 2)
                             *addr_index0 = *addr_swap;
                             *addr_swap = tmp;
                         }
-
                         break;
-                    }
-
-                    case NPTypeCode.Decimal:
-                    {
-                        var addr = (decimal*)x.Address;
+			        }
+			        case NPTypeCode.Double:
+			        {
+				        var addr = (double*)x.Address;
                         var addr_index0 = addr + transformOffset(0);
-                        decimal tmp; //index 0
-                        decimal* addr_swap;
+                        double tmp; //index 0
+                        double* addr_swap;
                         while (count-- > 1)
                         {
                             tmp = *addr_index0;
@@ -251,16 +138,12 @@ public void shuffle(NDArray x, int passes = 2)
                             *addr_index0 = *addr_swap;
                             *addr_swap = tmp;
                         }
-
                         break;
-                    }
-
-                    default:
-                        throw new NotSupportedException();
-                }
-
+			        }
+			        default:
+				        throw new NotSupportedException();
+		        }
                 #endregion
-
 #endif
             }
         }
diff --git a/src/NumSharp.Core/Selection/NDArray.Indexing.Masking.cs b/src/NumSharp.Core/Selection/NDArray.Indexing.Masking.cs
index d0b4f9ae1..c62eddfce 100644
--- a/src/NumSharp.Core/Selection/NDArray.Indexing.Masking.cs
+++ b/src/NumSharp.Core/Selection/NDArray.Indexing.Masking.cs
@@ -23,7 +23,18 @@ public NDArray this[NDArray<bool> mask]
             get => FetchIndices(this, np.nonzero(mask), null, true);
             set
             {
-                throw new NotImplementedException("Setter is not implemented yet");
+                if(mask.ndim == 1)
+                {
+                    for (int i = 0; i < mask.size; i++)
+                    {
+                        if (mask.GetBoolean(i))
+                            this[i] = value;
+                    }
+                }
+                else
+                {
+                    throw new NotImplementedException("Setter is not implemented yet");
+                }
             }
         }
     }
diff --git a/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Getter.cs b/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Getter.cs
index 091dde0a3..bba31d0cd 100644
--- a/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Getter.cs
+++ b/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Getter.cs
@@ -237,7 +237,7 @@ private NDArray FetchIndices(object[] indicesObjects)
 
         protected static NDArray FetchIndices(NDArray src, NDArray[] indices, NDArray @out, bool extraDim)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (src.typecode)
 		    {
@@ -251,27 +251,18 @@ protected static NDArray FetchIndices(NDArray src, NDArray[] indices, NDArray @o
 #else
 
             #region Compute
-
-            switch (src.typecode)
-            {
-                case NPTypeCode.Boolean: return FetchIndices<bool>(src.MakeGeneric<bool>(), indices, @out, extraDim);
-                case NPTypeCode.Byte: return FetchIndices<byte>(src.MakeGeneric<byte>(), indices, @out, extraDim);
-                case NPTypeCode.Int16: return FetchIndices<short>(src.MakeGeneric<short>(), indices, @out, extraDim);
-                case NPTypeCode.UInt16: return FetchIndices<ushort>(src.MakeGeneric<ushort>(), indices, @out, extraDim);
-                case NPTypeCode.Int32: return FetchIndices<int>(src.MakeGeneric<int>(), indices, @out, extraDim);
-                case NPTypeCode.UInt32: return FetchIndices<uint>(src.MakeGeneric<uint>(), indices, @out, extraDim);
-                case NPTypeCode.Int64: return FetchIndices<long>(src.MakeGeneric<long>(), indices, @out, extraDim);
-                case NPTypeCode.UInt64: return FetchIndices<ulong>(src.MakeGeneric<ulong>(), indices, @out, extraDim);
-                case NPTypeCode.Char: return FetchIndices<char>(src.MakeGeneric<char>(), indices, @out, extraDim);
-                case NPTypeCode.Double: return FetchIndices<double>(src.MakeGeneric<double>(), indices, @out, extraDim);
-                case NPTypeCode.Single: return FetchIndices<float>(src.MakeGeneric<float>(), indices, @out, extraDim);
-                case NPTypeCode.Decimal: return FetchIndices<decimal>(src.MakeGeneric<decimal>(), indices, @out, extraDim);
-                default:
-                    throw new NotSupportedException();
-            }
-
+		    switch (src.typecode)
+		    {
+			    case NPTypeCode.Boolean: return FetchIndices<bool>(src.MakeGeneric<bool>(), indices, @out, extraDim);
+			    case NPTypeCode.Byte: return FetchIndices<byte>(src.MakeGeneric<byte>(), indices, @out, extraDim);
+			    case NPTypeCode.Int32: return FetchIndices<int>(src.MakeGeneric<int>(), indices, @out, extraDim);
+			    case NPTypeCode.Int64: return FetchIndices<long>(src.MakeGeneric<long>(), indices, @out, extraDim);
+			    case NPTypeCode.Single: return FetchIndices<float>(src.MakeGeneric<float>(), indices, @out, extraDim);
+			    case NPTypeCode.Double: return FetchIndices<double>(src.MakeGeneric<double>(), indices, @out, extraDim);
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
 
diff --git a/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Setter.cs b/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Setter.cs
index 683379908..d315d92b4 100644
--- a/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Setter.cs
+++ b/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Setter.cs
@@ -253,7 +253,7 @@ protected void SetIndices(object[] indicesObjects, NDArray values)
 
         protected static void SetIndices(NDArray src, NDArray[] indices, NDArray values)
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
 		    switch (src.typecode)
 		    {
@@ -267,51 +267,18 @@ protected static void SetIndices(NDArray src, NDArray[] indices, NDArray values)
 #else
 
             #region Compute
-
-            switch (src.typecode)
-            {
-                case NPTypeCode.Boolean:
-                    SetIndices<bool>(src.MakeGeneric<bool>(), indices, values);
-                    break;
-                case NPTypeCode.Byte:
-                    SetIndices<byte>(src.MakeGeneric<byte>(), indices, values);
-                    break;
-                case NPTypeCode.Int16:
-                    SetIndices<short>(src.MakeGeneric<short>(), indices, values);
-                    break;
-                case NPTypeCode.UInt16:
-                    SetIndices<ushort>(src.MakeGeneric<ushort>(), indices, values);
-                    break;
-                case NPTypeCode.Int32:
-                    SetIndices<int>(src.MakeGeneric<int>(), indices, values);
-                    break;
-                case NPTypeCode.UInt32:
-                    SetIndices<uint>(src.MakeGeneric<uint>(), indices, values);
-                    break;
-                case NPTypeCode.Int64:
-                    SetIndices<long>(src.MakeGeneric<long>(), indices, values);
-                    break;
-                case NPTypeCode.UInt64:
-                    SetIndices<ulong>(src.MakeGeneric<ulong>(), indices, values);
-                    break;
-                case NPTypeCode.Char:
-                    SetIndices<char>(src.MakeGeneric<char>(), indices, values);
-                    break;
-                case NPTypeCode.Double:
-                    SetIndices<double>(src.MakeGeneric<double>(), indices, values);
-                    break;
-                case NPTypeCode.Single:
-                    SetIndices<float>(src.MakeGeneric<float>(), indices, values);
-                    break;
-                case NPTypeCode.Decimal:
-                    SetIndices<decimal>(src.MakeGeneric<decimal>(), indices, values);
-                    break;
-                default:
-                    throw new NotSupportedException();
-            }
-
+		    switch (src.typecode)
+		    {
+			    case NPTypeCode.Boolean: SetIndices<bool>(src.MakeGeneric<bool>(), indices, values); break;
+			    case NPTypeCode.Byte: SetIndices<byte>(src.MakeGeneric<byte>(), indices, values); break;
+			    case NPTypeCode.Int32: SetIndices<int>(src.MakeGeneric<int>(), indices, values); break;
+			    case NPTypeCode.Int64: SetIndices<long>(src.MakeGeneric<long>(), indices, values); break;
+			    case NPTypeCode.Single: SetIndices<float>(src.MakeGeneric<float>(), indices, values); break;
+			    case NPTypeCode.Double: SetIndices<double>(src.MakeGeneric<double>(), indices, values); break;
+			    default:
+				    throw new NotSupportedException();
+		    }
             #endregion
-
 #endif
         }
 
diff --git a/src/NumSharp.Core/Utilities/ArrayConvert.cs b/src/NumSharp.Core/Utilities/ArrayConvert.cs
index 722b80c25..fb37785bc 100644
--- a/src/NumSharp.Core/Utilities/ArrayConvert.cs
+++ b/src/NumSharp.Core/Utilities/ArrayConvert.cs
@@ -152,23 +152,17 @@ public static Array To(Array sourceArray, Type returnType)
 
             switch (returnType.GetTypeCode())
             {
-#if _REGEN
+#if _REGEN1
                 %foreach supported_dtypes %
                 case NPTypeCode.#1: return To#1(sourceArray);
                 %
 #else
                 case NPTypeCode.Boolean: return ToBoolean(sourceArray);
                 case NPTypeCode.Byte: return ToByte(sourceArray);
-                case NPTypeCode.Int16: return ToInt16(sourceArray);
-                case NPTypeCode.UInt16: return ToUInt16(sourceArray);
                 case NPTypeCode.Int32: return ToInt32(sourceArray);
-                case NPTypeCode.UInt32: return ToUInt32(sourceArray);
                 case NPTypeCode.Int64: return ToInt64(sourceArray);
-                case NPTypeCode.UInt64: return ToUInt64(sourceArray);
-                case NPTypeCode.Char: return ToChar(sourceArray);
-                case NPTypeCode.Double: return ToDouble(sourceArray);
                 case NPTypeCode.Single: return ToSingle(sourceArray);
-                case NPTypeCode.Decimal: return ToDecimal(sourceArray);
+                case NPTypeCode.Double: return ToDouble(sourceArray);
 #endif
                 default:
                     throw new NotSupportedException($"Unable to convert {sourceArray.GetType().GetElementType()?.Name} to {returnType?.Name}.");
@@ -186,7 +180,7 @@ public static Array To(Array sourceArray, NPTypeCode typeCode)
         {
             switch (typeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %foreach supported_dtypes %
                 case NPTypeCode.#1: return To#1(sourceArray);
                 %
@@ -194,16 +188,10 @@ public static Array To(Array sourceArray, NPTypeCode typeCode)
 
                 case NPTypeCode.Boolean: return ToBoolean(sourceArray);
                 case NPTypeCode.Byte: return ToByte(sourceArray);
-                case NPTypeCode.Int16: return ToInt16(sourceArray);
-                case NPTypeCode.UInt16: return ToUInt16(sourceArray);
                 case NPTypeCode.Int32: return ToInt32(sourceArray);
-                case NPTypeCode.UInt32: return ToUInt32(sourceArray);
                 case NPTypeCode.Int64: return ToInt64(sourceArray);
-                case NPTypeCode.UInt64: return ToUInt64(sourceArray);
-                case NPTypeCode.Char: return ToChar(sourceArray);
-                case NPTypeCode.Double: return ToDouble(sourceArray);
                 case NPTypeCode.Single: return ToSingle(sourceArray);
-                case NPTypeCode.Decimal: return ToDecimal(sourceArray);
+                case NPTypeCode.Double: return ToDouble(sourceArray);
 #endif
                 default:
                     throw new NotSupportedException($"Unable to convert {sourceArray.GetType().GetElementType()?.Name} to NPTypeCode.{typeCode}.");
@@ -226,7 +214,7 @@ public static T[] To<T>(Array sourceArray)
 
         #region From NonGeneric
 
-#if _REGEN
+#if _REGEN1
         %foreach all_dtypes%
 
         public static #1[] To#1(Array sourceArray)
@@ -243,26 +231,12 @@ public static T[] To<T>(Array sourceArray)
                     return To#1((Boolean[]) sourceArray);
                 case NPTypeCode.Byte:
                     return To#1((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return To#1((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return To#1((UInt16[]) sourceArray);
                 case NPTypeCode.Int32:
                     return To#1((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return To#1((UInt32[]) sourceArray);
                 case NPTypeCode.Int64:
                     return To#1((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return To#1((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return To#1((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return To#1((Double[]) sourceArray);
                 case NPTypeCode.Single:
                     return To#1((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return To#1((Decimal[]) sourceArray);
                 case NPTypeCode.String:
                     return To#1((String[]) sourceArray);
                 default:
@@ -286,26 +260,12 @@ public static Boolean[] ToBoolean(Array sourceArray)
                     return ToBoolean((Boolean[]) sourceArray);
                 case NPTypeCode.Byte:
                     return ToBoolean((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToBoolean((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToBoolean((UInt16[]) sourceArray);
                 case NPTypeCode.Int32:
                     return ToBoolean((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToBoolean((UInt32[]) sourceArray);
                 case NPTypeCode.Int64:
                     return ToBoolean((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToBoolean((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToBoolean((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToBoolean((Double[]) sourceArray);
                 case NPTypeCode.Single:
                     return ToBoolean((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToBoolean((Decimal[]) sourceArray);
                 case NPTypeCode.String:
                     return ToBoolean((String[]) sourceArray);
                 default:
@@ -327,26 +287,12 @@ public static Byte[] ToByte(Array sourceArray)
                     return ToByte((Boolean[]) sourceArray);
                 case NPTypeCode.Byte:
                     return ToByte((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToByte((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToByte((UInt16[]) sourceArray);
                 case NPTypeCode.Int32:
                     return ToByte((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToByte((UInt32[]) sourceArray);
                 case NPTypeCode.Int64:
                     return ToByte((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToByte((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToByte((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToByte((Double[]) sourceArray);
                 case NPTypeCode.Single:
                     return ToByte((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToByte((Decimal[]) sourceArray);
                 case NPTypeCode.String:
                     return ToByte((String[]) sourceArray);
                 default:
@@ -354,88 +300,6 @@ public static Byte[] ToByte(Array sourceArray)
             }
         }
 
-        public static Int16[] ToInt16(Array sourceArray)
-        {
-            if (sourceArray == null)
-            {
-                throw new ArgumentNullException(nameof(sourceArray));
-            }
-
-            var fromTypeCode = sourceArray.GetType().GetElementType().GetTypeCode();
-            switch (fromTypeCode)
-            {
-                case NPTypeCode.Boolean:
-                    return ToInt16((Boolean[]) sourceArray);
-                case NPTypeCode.Byte:
-                    return ToInt16((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToInt16((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToInt16((UInt16[]) sourceArray);
-                case NPTypeCode.Int32:
-                    return ToInt16((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToInt16((UInt32[]) sourceArray);
-                case NPTypeCode.Int64:
-                    return ToInt16((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToInt16((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToInt16((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToInt16((Double[]) sourceArray);
-                case NPTypeCode.Single:
-                    return ToInt16((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToInt16((Decimal[]) sourceArray);
-                case NPTypeCode.String:
-                    return ToInt16((String[]) sourceArray);
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-
-        public static UInt16[] ToUInt16(Array sourceArray)
-        {
-            if (sourceArray == null)
-            {
-                throw new ArgumentNullException(nameof(sourceArray));
-            }
-
-            var fromTypeCode = sourceArray.GetType().GetElementType().GetTypeCode();
-            switch (fromTypeCode)
-            {
-                case NPTypeCode.Boolean:
-                    return ToUInt16((Boolean[]) sourceArray);
-                case NPTypeCode.Byte:
-                    return ToUInt16((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToUInt16((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToUInt16((UInt16[]) sourceArray);
-                case NPTypeCode.Int32:
-                    return ToUInt16((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToUInt16((UInt32[]) sourceArray);
-                case NPTypeCode.Int64:
-                    return ToUInt16((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToUInt16((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToUInt16((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToUInt16((Double[]) sourceArray);
-                case NPTypeCode.Single:
-                    return ToUInt16((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToUInt16((Decimal[]) sourceArray);
-                case NPTypeCode.String:
-                    return ToUInt16((String[]) sourceArray);
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-
         public static Int32[] ToInt32(Array sourceArray)
         {
             if (sourceArray == null)
@@ -450,26 +314,12 @@ public static Int32[] ToInt32(Array sourceArray)
                     return ToInt32((Boolean[]) sourceArray);
                 case NPTypeCode.Byte:
                     return ToInt32((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToInt32((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToInt32((UInt16[]) sourceArray);
                 case NPTypeCode.Int32:
                     return ToInt32((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToInt32((UInt32[]) sourceArray);
                 case NPTypeCode.Int64:
                     return ToInt32((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToInt32((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToInt32((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToInt32((Double[]) sourceArray);
                 case NPTypeCode.Single:
                     return ToInt32((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToInt32((Decimal[]) sourceArray);
                 case NPTypeCode.String:
                     return ToInt32((String[]) sourceArray);
                 default:
@@ -477,47 +327,6 @@ public static Int32[] ToInt32(Array sourceArray)
             }
         }
 
-        public static UInt32[] ToUInt32(Array sourceArray)
-        {
-            if (sourceArray == null)
-            {
-                throw new ArgumentNullException(nameof(sourceArray));
-            }
-
-            var fromTypeCode = sourceArray.GetType().GetElementType().GetTypeCode();
-            switch (fromTypeCode)
-            {
-                case NPTypeCode.Boolean:
-                    return ToUInt32((Boolean[]) sourceArray);
-                case NPTypeCode.Byte:
-                    return ToUInt32((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToUInt32((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToUInt32((UInt16[]) sourceArray);
-                case NPTypeCode.Int32:
-                    return ToUInt32((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToUInt32((UInt32[]) sourceArray);
-                case NPTypeCode.Int64:
-                    return ToUInt32((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToUInt32((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToUInt32((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToUInt32((Double[]) sourceArray);
-                case NPTypeCode.Single:
-                    return ToUInt32((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToUInt32((Decimal[]) sourceArray);
-                case NPTypeCode.String:
-                    return ToUInt32((String[]) sourceArray);
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-
         public static Int64[] ToInt64(Array sourceArray)
         {
             if (sourceArray == null)
@@ -532,26 +341,12 @@ public static Int64[] ToInt64(Array sourceArray)
                     return ToInt64((Boolean[]) sourceArray);
                 case NPTypeCode.Byte:
                     return ToInt64((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToInt64((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToInt64((UInt16[]) sourceArray);
                 case NPTypeCode.Int32:
                     return ToInt64((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToInt64((UInt32[]) sourceArray);
                 case NPTypeCode.Int64:
                     return ToInt64((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToInt64((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToInt64((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToInt64((Double[]) sourceArray);
                 case NPTypeCode.Single:
                     return ToInt64((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToInt64((Decimal[]) sourceArray);
                 case NPTypeCode.String:
                     return ToInt64((String[]) sourceArray);
                 default:
@@ -559,129 +354,6 @@ public static Int64[] ToInt64(Array sourceArray)
             }
         }
 
-        public static UInt64[] ToUInt64(Array sourceArray)
-        {
-            if (sourceArray == null)
-            {
-                throw new ArgumentNullException(nameof(sourceArray));
-            }
-
-            var fromTypeCode = sourceArray.GetType().GetElementType().GetTypeCode();
-            switch (fromTypeCode)
-            {
-                case NPTypeCode.Boolean:
-                    return ToUInt64((Boolean[]) sourceArray);
-                case NPTypeCode.Byte:
-                    return ToUInt64((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToUInt64((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToUInt64((UInt16[]) sourceArray);
-                case NPTypeCode.Int32:
-                    return ToUInt64((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToUInt64((UInt32[]) sourceArray);
-                case NPTypeCode.Int64:
-                    return ToUInt64((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToUInt64((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToUInt64((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToUInt64((Double[]) sourceArray);
-                case NPTypeCode.Single:
-                    return ToUInt64((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToUInt64((Decimal[]) sourceArray);
-                case NPTypeCode.String:
-                    return ToUInt64((String[]) sourceArray);
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-
-        public static Char[] ToChar(Array sourceArray)
-        {
-            if (sourceArray == null)
-            {
-                throw new ArgumentNullException(nameof(sourceArray));
-            }
-
-            var fromTypeCode = sourceArray.GetType().GetElementType().GetTypeCode();
-            switch (fromTypeCode)
-            {
-                case NPTypeCode.Boolean:
-                    return ToChar((Boolean[]) sourceArray);
-                case NPTypeCode.Byte:
-                    return ToChar((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToChar((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToChar((UInt16[]) sourceArray);
-                case NPTypeCode.Int32:
-                    return ToChar((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToChar((UInt32[]) sourceArray);
-                case NPTypeCode.Int64:
-                    return ToChar((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToChar((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToChar((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToChar((Double[]) sourceArray);
-                case NPTypeCode.Single:
-                    return ToChar((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToChar((Decimal[]) sourceArray);
-                case NPTypeCode.String:
-                    return ToChar((String[]) sourceArray);
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-
-        public static Double[] ToDouble(Array sourceArray)
-        {
-            if (sourceArray == null)
-            {
-                throw new ArgumentNullException(nameof(sourceArray));
-            }
-
-            var fromTypeCode = sourceArray.GetType().GetElementType().GetTypeCode();
-            switch (fromTypeCode)
-            {
-                case NPTypeCode.Boolean:
-                    return ToDouble((Boolean[]) sourceArray);
-                case NPTypeCode.Byte:
-                    return ToDouble((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToDouble((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToDouble((UInt16[]) sourceArray);
-                case NPTypeCode.Int32:
-                    return ToDouble((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToDouble((UInt32[]) sourceArray);
-                case NPTypeCode.Int64:
-                    return ToDouble((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToDouble((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToDouble((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToDouble((Double[]) sourceArray);
-                case NPTypeCode.Single:
-                    return ToDouble((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToDouble((Decimal[]) sourceArray);
-                case NPTypeCode.String:
-                    return ToDouble((String[]) sourceArray);
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-
         public static Single[] ToSingle(Array sourceArray)
         {
             if (sourceArray == null)
@@ -696,26 +368,12 @@ public static Single[] ToSingle(Array sourceArray)
                     return ToSingle((Boolean[]) sourceArray);
                 case NPTypeCode.Byte:
                     return ToSingle((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToSingle((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToSingle((UInt16[]) sourceArray);
                 case NPTypeCode.Int32:
                     return ToSingle((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToSingle((UInt32[]) sourceArray);
                 case NPTypeCode.Int64:
                     return ToSingle((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToSingle((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToSingle((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToSingle((Double[]) sourceArray);
                 case NPTypeCode.Single:
                     return ToSingle((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToSingle((Decimal[]) sourceArray);
                 case NPTypeCode.String:
                     return ToSingle((String[]) sourceArray);
                 default:
@@ -723,7 +381,7 @@ public static Single[] ToSingle(Array sourceArray)
             }
         }
 
-        public static Decimal[] ToDecimal(Array sourceArray)
+        public static Double[] ToDouble(Array sourceArray)
         {
             if (sourceArray == null)
             {
@@ -734,31 +392,17 @@ public static Decimal[] ToDecimal(Array sourceArray)
             switch (fromTypeCode)
             {
                 case NPTypeCode.Boolean:
-                    return ToDecimal((Boolean[]) sourceArray);
+                    return ToDouble((Boolean[]) sourceArray);
                 case NPTypeCode.Byte:
-                    return ToDecimal((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToDecimal((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToDecimal((UInt16[]) sourceArray);
+                    return ToDouble((Byte[]) sourceArray);
                 case NPTypeCode.Int32:
-                    return ToDecimal((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToDecimal((UInt32[]) sourceArray);
+                    return ToDouble((Int32[]) sourceArray);
                 case NPTypeCode.Int64:
-                    return ToDecimal((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToDecimal((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToDecimal((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToDecimal((Double[]) sourceArray);
+                    return ToDouble((Int64[]) sourceArray);
                 case NPTypeCode.Single:
-                    return ToDecimal((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToDecimal((Decimal[]) sourceArray);
+                    return ToDouble((Single[]) sourceArray);
                 case NPTypeCode.String:
-                    return ToDecimal((String[]) sourceArray);
+                    return ToDouble((String[]) sourceArray);
                 default:
                     throw new ArgumentOutOfRangeException();
             }
@@ -778,73 +422,18 @@ public static String[] ToString(Array sourceArray)
                     return ToString((Boolean[]) sourceArray);
                 case NPTypeCode.Byte:
                     return ToString((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToString((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToString((UInt16[]) sourceArray);
                 case NPTypeCode.Int32:
                     return ToString((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToString((UInt32[]) sourceArray);
                 case NPTypeCode.Int64:
                     return ToString((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToString((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToString((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToString((Double[]) sourceArray);
                 case NPTypeCode.Single:
                     return ToString((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToString((Decimal[]) sourceArray);
                 case NPTypeCode.String:
                     return ToString((String[]) sourceArray);
                 default:
                     throw new ArgumentOutOfRangeException();
             }
         }
-
-        public static Complex[] ToComplex(Array sourceArray)
-        {
-            if (sourceArray == null)
-            {
-                throw new ArgumentNullException(nameof(sourceArray));
-            }
-
-            var fromTypeCode = sourceArray.GetType().GetElementType().GetTypeCode();
-            switch (fromTypeCode)
-            {
-                case NPTypeCode.Boolean:
-                    return ToComplex((Boolean[]) sourceArray);
-                case NPTypeCode.Byte:
-                    return ToComplex((Byte[]) sourceArray);
-                case NPTypeCode.Int16:
-                    return ToComplex((Int16[]) sourceArray);
-                case NPTypeCode.UInt16:
-                    return ToComplex((UInt16[]) sourceArray);
-                case NPTypeCode.Int32:
-                    return ToComplex((Int32[]) sourceArray);
-                case NPTypeCode.UInt32:
-                    return ToComplex((UInt32[]) sourceArray);
-                case NPTypeCode.Int64:
-                    return ToComplex((Int64[]) sourceArray);
-                case NPTypeCode.UInt64:
-                    return ToComplex((UInt64[]) sourceArray);
-                case NPTypeCode.Char:
-                    return ToComplex((Char[]) sourceArray);
-                case NPTypeCode.Double:
-                    return ToComplex((Double[]) sourceArray);
-                case NPTypeCode.Single:
-                    return ToComplex((Single[]) sourceArray);
-                case NPTypeCode.Decimal:
-                    return ToComplex((Decimal[]) sourceArray);
-                case NPTypeCode.String:
-                    return ToComplex((String[]) sourceArray);
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
 #endif
 
         #endregion
@@ -853,7 +442,7 @@ public static Complex[] ToComplex(Array sourceArray)
 
         #region To Same Type
 
-#if _REGEN
+#if _REGEN1
         %foreach all_dtypes%
         
         /// <summary>
@@ -878,6 +467,7 @@ public static Complex[] ToComplex(Array sourceArray)
 #else
 
 
+        
         /// <summary>
         ///     Converts <see cref="Boolean"/> array to a <see cref="Boolean"/> array.
         /// </summary>
@@ -889,14 +479,14 @@ public static Boolean[] ToBoolean(Boolean[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
-
+            
             var length = sourceArray.Length;
             var output = new Boolean[length];
             sourceArray.AsSpan().CopyTo(output);
 
             return output;
         }
-
+        
         /// <summary>
         ///     Converts <see cref="Byte"/> array to a <see cref="Byte"/> array.
         /// </summary>
@@ -908,357 +498,173 @@ public static Byte[] ToByte(Byte[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
-
+            
             var length = sourceArray.Length;
             var output = new Byte[length];
             sourceArray.AsSpan().CopyTo(output);
 
             return output;
         }
-
+        
         /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="Int16"/> array.
+        ///     Converts <see cref="Int32"/> array to a <see cref="Int32"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
+        /// <returns>Converted array of type Int32</returns>
         /// <remarks>Based on benchmark ArrayCopying</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(Int16[] sourceArray)
+        public static Int32[] ToInt32(Int32[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
-
+            
             var length = sourceArray.Length;
-            var output = new Int16[length];
+            var output = new Int32[length];
             sourceArray.AsSpan().CopyTo(output);
 
             return output;
         }
-
+        
         /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="UInt16"/> array.
+        ///     Converts <see cref="Int64"/> array to a <see cref="Int64"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
+        /// <returns>Converted array of type Int64</returns>
         /// <remarks>Based on benchmark ArrayCopying</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(UInt16[] sourceArray)
+        public static Int64[] ToInt64(Int64[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
-
+            
             var length = sourceArray.Length;
-            var output = new UInt16[length];
+            var output = new Int64[length];
             sourceArray.AsSpan().CopyTo(output);
 
             return output;
         }
-
+        
         /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="Int32"/> array.
+        ///     Converts <see cref="Single"/> array to a <see cref="Single"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
+        /// <returns>Converted array of type Single</returns>
         /// <remarks>Based on benchmark ArrayCopying</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(Int32[] sourceArray)
+        public static Single[] ToSingle(Single[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
-
+            
             var length = sourceArray.Length;
-            var output = new Int32[length];
+            var output = new Single[length];
             sourceArray.AsSpan().CopyTo(output);
 
             return output;
         }
-
+        
         /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="UInt32"/> array.
+        ///     Converts <see cref="Double"/> array to a <see cref="Double"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
+        /// <returns>Converted array of type Double</returns>
         /// <remarks>Based on benchmark ArrayCopying</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(UInt32[] sourceArray)
+        public static Double[] ToDouble(Double[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
-
+            
             var length = sourceArray.Length;
-            var output = new UInt32[length];
+            var output = new Double[length];
             sourceArray.AsSpan().CopyTo(output);
 
             return output;
         }
-
+        
         /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="Int64"/> array.
+        ///     Converts <see cref="String"/> array to a <see cref="String"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
+        /// <returns>Converted array of type String</returns>
         /// <remarks>Based on benchmark ArrayCopying</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(Int64[] sourceArray)
+        public static String[] ToString(String[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
-
+            
             var length = sourceArray.Length;
-            var output = new Int64[length];
+            var output = new String[length];
             sourceArray.AsSpan().CopyTo(output);
 
             return output;
         }
+#endif
+
+        #endregion
 
+#if _REGEN1
+        #region Compute
+        %foreach forevery(supported_primitives, supported_primitives, true)%
+        
         /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="UInt64"/> array.
+        ///     Converts <see cref="#1"/> array to a <see cref="#2"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        /// <remarks>Based on benchmark ArrayCopying</remarks>
+        /// <returns>Converted array of type #2</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(UInt64[] sourceArray)
+        public static #2[] To#2(#1[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
-
+            
             var length = sourceArray.Length;
-            var output = new UInt64[length];
-            sourceArray.AsSpan().CopyTo(output);
-
+            var output = new #2[length];
+            Parallel.For(0, length, i=> output[i] = Converts.To#2(sourceArray[i]));
             return output;
         }
+        %
+        #endregion
+#else
 
+
+        #region Compute
+        
         /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="Char"/> array.
+        ///     Converts <see cref="Boolean"/> array to a <see cref="Byte"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        /// <remarks>Based on benchmark ArrayCopying</remarks>
+        /// <returns>Converted array of type Byte</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(Char[] sourceArray)
+        public static Byte[] ToByte(Boolean[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
-
+            
             var length = sourceArray.Length;
-            var output = new Char[length];
-            sourceArray.AsSpan().CopyTo(output);
-
+            var output = new Byte[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
             return output;
         }
-
+        
         /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="Double"/> array.
+        ///     Converts <see cref="Boolean"/> array to a <see cref="Int32"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
-        /// <remarks>Based on benchmark ArrayCopying</remarks>
+        /// <returns>Converted array of type Int32</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(Double[] sourceArray)
+        public static Int32[] ToInt32(Boolean[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
-
-            var length = sourceArray.Length;
-            var output = new Double[length];
-            sourceArray.AsSpan().CopyTo(output);
-
-            return output;
-        }
-
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="Single"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
-        /// <remarks>Based on benchmark ArrayCopying</remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(Single[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-
-            var length = sourceArray.Length;
-            var output = new Single[length];
-            sourceArray.AsSpan().CopyTo(output);
-
-            return output;
-        }
-
-        /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="Decimal"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
-        /// <remarks>Based on benchmark ArrayCopying</remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(Decimal[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-
-            var length = sourceArray.Length;
-            var output = new Decimal[length];
-            sourceArray.AsSpan().CopyTo(output);
-
-            return output;
-        }
-
-        /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="String"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type String</returns>
-        /// <remarks>Based on benchmark ArrayCopying</remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(String[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-
-            var length = sourceArray.Length;
-            var output = new String[length];
-            sourceArray.AsSpan().CopyTo(output);
-
-            return output;
-        }
-
-        /// <summary>
-        ///     Converts <see cref="Complex"/> array to a <see cref="Complex"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Complex</returns>
-        /// <remarks>Based on benchmark ArrayCopying</remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(Complex[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-
-            var length = sourceArray.Length;
-            var output = new Complex[length];
-            sourceArray.AsSpan().CopyTo(output);
-
-            return output;
-        }
-#endif
-
-        #endregion
-
-#if _REGEN
-        #region Compute
-        %foreach forevery(supported_primitives, supported_primitives, true)%
-        
-        /// <summary>
-        ///     Converts <see cref="#1"/> array to a <see cref="#2"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type #2</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static #2[] To#2(#1[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new #2[length];
-            Parallel.For(0, length, i=> output[i] = Converts.To#2(sourceArray[i]));
-            return output;
-        }
-        %
-        #endregion
-#else
-
-
-        #region Compute
-        
-        /// <summary>
-        ///     Converts <see cref="Boolean"/> array to a <see cref="Byte"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Byte</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(Boolean[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Byte[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Boolean"/> array to a <see cref="Int16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(Boolean[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Boolean"/> array to a <see cref="UInt16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(Boolean[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Boolean"/> array to a <see cref="Int32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(Boolean[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
+            
             var length = sourceArray.Length;
             var output = new Int32[length];
             Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
             return output;
         }
         
-        /// <summary>
-        ///     Converts <see cref="Boolean"/> array to a <see cref="UInt32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(Boolean[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
-            return output;
-        }
-        
         /// <summary>
         ///     Converts <see cref="Boolean"/> array to a <see cref="Int64"/> array.
         /// </summary>
@@ -1276,57 +682,6 @@ public static Int64[] ToInt64(Boolean[] sourceArray)
             return output;
         }
         
-        /// <summary>
-        ///     Converts <see cref="Boolean"/> array to a <see cref="UInt64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(Boolean[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Boolean"/> array to a <see cref="Char"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(Boolean[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Boolean"/> array to a <see cref="Double"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(Boolean[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
-            return output;
-        }
-        
         /// <summary>
         ///     Converts <see cref="Boolean"/> array to a <see cref="Single"/> array.
         /// </summary>
@@ -1345,19 +700,19 @@ public static Single[] ToSingle(Boolean[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="Boolean"/> array to a <see cref="Decimal"/> array.
+        ///     Converts <see cref="Boolean"/> array to a <see cref="Double"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
+        /// <returns>Converted array of type Double</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(Boolean[] sourceArray)
+        public static Double[] ToDouble(Boolean[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
+            var output = new Double[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
             return output;
         }
         
@@ -1395,40 +750,6 @@ public static Boolean[] ToBoolean(Byte[] sourceArray)
             return output;
         }
         
-        /// <summary>
-        ///     Converts <see cref="Byte"/> array to a <see cref="Int16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(Byte[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Byte"/> array to a <see cref="UInt16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(Byte[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
-            return output;
-        }
-        
         /// <summary>
         ///     Converts <see cref="Byte"/> array to a <see cref="Int32"/> array.
         /// </summary>
@@ -1446,23 +767,6 @@ public static Int32[] ToInt32(Byte[] sourceArray)
             return output;
         }
         
-        /// <summary>
-        ///     Converts <see cref="Byte"/> array to a <see cref="UInt32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(Byte[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
-            return output;
-        }
-        
         /// <summary>
         ///     Converts <see cref="Byte"/> array to a <see cref="Int64"/> array.
         /// </summary>
@@ -1481,1933 +785,46 @@ public static Int64[] ToInt64(Byte[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="Byte"/> array to a <see cref="UInt64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(Byte[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Byte"/> array to a <see cref="Char"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(Byte[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Byte"/> array to a <see cref="Double"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(Byte[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Byte"/> array to a <see cref="Single"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(Byte[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Single[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Byte"/> array to a <see cref="Decimal"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(Byte[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Byte"/> array to a <see cref="String"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type String</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(Byte[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new String[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="Boolean"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Boolean</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Boolean[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="Byte"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Byte</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Byte[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="UInt16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="Int32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="UInt32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="Int64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="UInt64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="Char"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="Double"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="Single"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Single[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="Decimal"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="String"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type String</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(Int16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new String[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="Boolean"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Boolean</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Boolean[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="Byte"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Byte</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Byte[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="Int16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="Int32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="UInt32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="Int64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="UInt64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="Char"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="Double"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="Single"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Single[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="Decimal"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="String"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type String</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(UInt16[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new String[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="Boolean"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Boolean</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Boolean[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="Byte"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Byte</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Byte[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="Int16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="UInt16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="UInt32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="Int64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="UInt64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="Char"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="Double"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="Single"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Single[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="Decimal"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="String"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type String</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(Int32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new String[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="Boolean"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Boolean</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Boolean[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="Byte"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Byte</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Byte[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="Int16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="UInt16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="Int32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="Int64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="UInt64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="Char"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="Double"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="Single"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Single[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="Decimal"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="String"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type String</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(UInt32[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new String[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="Boolean"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Boolean</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Boolean[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="Byte"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Byte</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Byte[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="Int16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="UInt16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="Int32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="UInt32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="UInt64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="Char"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="Double"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="Single"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Single[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="Decimal"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="String"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type String</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(Int64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new String[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="Boolean"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Boolean</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Boolean[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="Byte"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Byte</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Byte[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="Int16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="UInt16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="Int32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="UInt32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="Int64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="Char"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="Double"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="Single"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Single[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="Decimal"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="String"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type String</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(UInt64[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new String[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="Boolean"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Boolean</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Boolean[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="Byte"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Byte</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Byte[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="Int16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="UInt16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="Int32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="UInt32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="Int64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="UInt64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="Double"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="Single"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Single[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="Decimal"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="String"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type String</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(Char[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new String[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="Boolean"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Boolean</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Boolean[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="Byte"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Byte</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Byte[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="Int16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="UInt16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="Int32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="UInt32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="Int64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="UInt64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="Char"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="Single"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Single[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="Decimal"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="String"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type String</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(Double[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new String[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="Boolean"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Boolean</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(Single[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Boolean[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="Byte"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Byte</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(Single[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Byte[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="Int16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(Single[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="UInt16"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(Single[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="Int32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(Single[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="UInt32"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(Single[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="Int64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(Single[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Int64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="UInt64"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(Single[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="Char"/> array.
-        /// </summary>
-        /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(Single[] sourceArray)
-        {
-            if (sourceArray == null)
-                throw new ArgumentNullException(nameof(sourceArray));
-            
-            var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
-            return output;
-        }
-        
-        /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="Double"/> array.
+        ///     Converts <see cref="Byte"/> array to a <see cref="Single"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
+        /// <returns>Converted array of type Single</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(Single[] sourceArray)
+        public static Single[] ToSingle(Byte[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
+            var output = new Single[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="Decimal"/> array.
+        ///     Converts <see cref="Byte"/> array to a <see cref="Double"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
+        /// <returns>Converted array of type Double</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(Single[] sourceArray)
+        public static Double[] ToDouble(Byte[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
+            var output = new Double[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Single"/> array to a <see cref="String"/> array.
+        ///     Converts <see cref="Byte"/> array to a <see cref="String"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type String</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(Single[] sourceArray)
+        public static String[] ToString(Byte[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -3419,12 +836,12 @@ public static String[] ToString(Single[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="Boolean"/> array.
+        ///     Converts <see cref="Int32"/> array to a <see cref="Boolean"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Boolean</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(Decimal[] sourceArray)
+        public static Boolean[] ToBoolean(Int32[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -3436,12 +853,12 @@ public static Boolean[] ToBoolean(Decimal[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="Byte"/> array.
+        ///     Converts <see cref="Int32"/> array to a <see cref="Byte"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Byte</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(Decimal[] sourceArray)
+        public static Byte[] ToByte(Int32[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -3453,165 +870,165 @@ public static Byte[] ToByte(Decimal[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="Int16"/> array.
+        ///     Converts <see cref="Int32"/> array to a <see cref="Int64"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
+        /// <returns>Converted array of type Int64</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(Decimal[] sourceArray)
+        public static Int64[] ToInt64(Int32[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
+            var output = new Int64[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="UInt16"/> array.
+        ///     Converts <see cref="Int32"/> array to a <see cref="Single"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
+        /// <returns>Converted array of type Single</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(Decimal[] sourceArray)
+        public static Single[] ToSingle(Int32[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
+            var output = new Single[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="Int32"/> array.
+        ///     Converts <see cref="Int32"/> array to a <see cref="Double"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
+        /// <returns>Converted array of type Double</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(Decimal[] sourceArray)
+        public static Double[] ToDouble(Int32[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Int32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
+            var output = new Double[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="UInt32"/> array.
+        ///     Converts <see cref="Int32"/> array to a <see cref="String"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
+        /// <returns>Converted array of type String</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(Decimal[] sourceArray)
+        public static String[] ToString(Int32[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
+            var output = new String[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="Int64"/> array.
+        ///     Converts <see cref="Int64"/> array to a <see cref="Boolean"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
+        /// <returns>Converted array of type Boolean</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(Decimal[] sourceArray)
+        public static Boolean[] ToBoolean(Int64[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Int64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
+            var output = new Boolean[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="UInt64"/> array.
+        ///     Converts <see cref="Int64"/> array to a <see cref="Byte"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
+        /// <returns>Converted array of type Byte</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(Decimal[] sourceArray)
+        public static Byte[] ToByte(Int64[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
+            var output = new Byte[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="Char"/> array.
+        ///     Converts <see cref="Int64"/> array to a <see cref="Int32"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
+        /// <returns>Converted array of type Int32</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(Decimal[] sourceArray)
+        public static Int32[] ToInt32(Int64[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
+            var output = new Int32[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="Double"/> array.
+        ///     Converts <see cref="Int64"/> array to a <see cref="Single"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
+        /// <returns>Converted array of type Single</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(Decimal[] sourceArray)
+        public static Single[] ToSingle(Int64[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
+            var output = new Single[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="Single"/> array.
+        ///     Converts <see cref="Int64"/> array to a <see cref="Double"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Single</returns>
+        /// <returns>Converted array of type Double</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(Decimal[] sourceArray)
+        public static Double[] ToDouble(Int64[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Single[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
+            var output = new Double[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="String"/> array.
+        ///     Converts <see cref="Int64"/> array to a <see cref="String"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type String</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String[] ToString(Decimal[] sourceArray)
+        public static String[] ToString(Int64[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -3623,12 +1040,12 @@ public static String[] ToString(Decimal[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="Boolean"/> array.
+        ///     Converts <see cref="Single"/> array to a <see cref="Boolean"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Boolean</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Boolean[] ToBoolean(String[] sourceArray)
+        public static Boolean[] ToBoolean(Single[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -3640,12 +1057,12 @@ public static Boolean[] ToBoolean(String[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="Byte"/> array.
+        ///     Converts <see cref="Single"/> array to a <see cref="Byte"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Byte</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Byte[] ToByte(String[] sourceArray)
+        public static Byte[] ToByte(Single[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -3657,148 +1074,148 @@ public static Byte[] ToByte(String[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="Int16"/> array.
+        ///     Converts <see cref="Single"/> array to a <see cref="Int32"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int16</returns>
+        /// <returns>Converted array of type Int32</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int16[] ToInt16(String[] sourceArray)
+        public static Int32[] ToInt32(Single[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Int16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt16(sourceArray[i]));
+            var output = new Int32[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="UInt16"/> array.
+        ///     Converts <see cref="Single"/> array to a <see cref="Int64"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt16</returns>
+        /// <returns>Converted array of type Int64</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt16[] ToUInt16(String[] sourceArray)
+        public static Int64[] ToInt64(Single[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new UInt16[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt16(sourceArray[i]));
+            var output = new Int64[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="Int32"/> array.
+        ///     Converts <see cref="Single"/> array to a <see cref="Double"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int32</returns>
+        /// <returns>Converted array of type Double</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int32[] ToInt32(String[] sourceArray)
+        public static Double[] ToDouble(Single[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Int32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
+            var output = new Double[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="UInt32"/> array.
+        ///     Converts <see cref="Single"/> array to a <see cref="String"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt32</returns>
+        /// <returns>Converted array of type String</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt32[] ToUInt32(String[] sourceArray)
+        public static String[] ToString(Single[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new UInt32[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt32(sourceArray[i]));
+            var output = new String[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="Int64"/> array.
+        ///     Converts <see cref="Double"/> array to a <see cref="Boolean"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Int64</returns>
+        /// <returns>Converted array of type Boolean</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Int64[] ToInt64(String[] sourceArray)
+        public static Boolean[] ToBoolean(Double[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Int64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
+            var output = new Boolean[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="UInt64"/> array.
+        ///     Converts <see cref="Double"/> array to a <see cref="Byte"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type UInt64</returns>
+        /// <returns>Converted array of type Byte</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static UInt64[] ToUInt64(String[] sourceArray)
+        public static Byte[] ToByte(Double[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new UInt64[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToUInt64(sourceArray[i]));
+            var output = new Byte[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="Char"/> array.
+        ///     Converts <see cref="Double"/> array to a <see cref="Int32"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Char</returns>
+        /// <returns>Converted array of type Int32</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Char[] ToChar(String[] sourceArray)
+        public static Int32[] ToInt32(Double[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Char[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToChar(sourceArray[i]));
+            var output = new Int32[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="Double"/> array.
+        ///     Converts <see cref="Double"/> array to a <see cref="Int64"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Double</returns>
+        /// <returns>Converted array of type Int64</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Double[] ToDouble(String[] sourceArray)
+        public static Int64[] ToInt64(Double[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Double[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
+            var output = new Int64[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="Single"/> array.
+        ///     Converts <see cref="Double"/> array to a <see cref="Single"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Single</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Single[] ToSingle(String[] sourceArray)
+        public static Single[] ToSingle(Double[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -3810,150 +1227,140 @@ public static Single[] ToSingle(String[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="String"/> array to a <see cref="Decimal"/> array.
+        ///     Converts <see cref="Double"/> array to a <see cref="String"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Decimal</returns>
+        /// <returns>Converted array of type String</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Decimal[] ToDecimal(String[] sourceArray)
+        public static String[] ToString(Double[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Decimal[length];
-            Parallel.For(0, length, i=> output[i] = Converts.ToDecimal(sourceArray[i]));
+            var output = new String[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToString(sourceArray[i]));
             return output;
         }
-        #endregion
-#endif
-
-        #endregion
-
-        #region Complex
-
-#if _REGEN
-        %foreach supported_primitives%
         
         /// <summary>
-        ///     Converts <see cref="#1"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="String"/> array to a <see cref="Boolean"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Complex</returns>
+        /// <returns>Converted array of type Boolean</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(#1[] sourceArray)
+        public static Boolean[] ToBoolean(String[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Complex[length];
-
-            Parallel.For(0, length, i => new Complex(Converts.ToDouble(sourceArray[i]), 0d));
+            var output = new Boolean[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToBoolean(sourceArray[i]));
             return output;
         }
-        %
-#else
-
-
         
         /// <summary>
-        ///     Converts <see cref="Boolean"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="String"/> array to a <see cref="Byte"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Complex</returns>
+        /// <returns>Converted array of type Byte</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(Boolean[] sourceArray)
+        public static Byte[] ToByte(String[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Complex[length];
-
-            Parallel.For(0, length, i => new Complex(Converts.ToDouble(sourceArray[i]), 0d));
+            var output = new Byte[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToByte(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Byte"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="String"/> array to a <see cref="Int32"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Complex</returns>
+        /// <returns>Converted array of type Int32</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(Byte[] sourceArray)
+        public static Int32[] ToInt32(String[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Complex[length];
-
-            Parallel.For(0, length, i => new Complex(Converts.ToDouble(sourceArray[i]), 0d));
+            var output = new Int32[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToInt32(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Int16"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="String"/> array to a <see cref="Int64"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Complex</returns>
+        /// <returns>Converted array of type Int64</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(Int16[] sourceArray)
+        public static Int64[] ToInt64(String[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Complex[length];
-
-            Parallel.For(0, length, i => new Complex(Converts.ToDouble(sourceArray[i]), 0d));
+            var output = new Int64[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToInt64(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="UInt16"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="String"/> array to a <see cref="Single"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Complex</returns>
+        /// <returns>Converted array of type Single</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(UInt16[] sourceArray)
+        public static Single[] ToSingle(String[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Complex[length];
-
-            Parallel.For(0, length, i => new Complex(Converts.ToDouble(sourceArray[i]), 0d));
+            var output = new Single[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToSingle(sourceArray[i]));
             return output;
         }
         
         /// <summary>
-        ///     Converts <see cref="Int32"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="String"/> array to a <see cref="Double"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
-        /// <returns>Converted array of type Complex</returns>
+        /// <returns>Converted array of type Double</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(Int32[] sourceArray)
+        public static Double[] ToDouble(String[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
             
             var length = sourceArray.Length;
-            var output = new Complex[length];
-
-            Parallel.For(0, length, i => new Complex(Converts.ToDouble(sourceArray[i]), 0d));
+            var output = new Double[length];
+            Parallel.For(0, length, i=> output[i] = Converts.ToDouble(sourceArray[i]));
             return output;
         }
+        #endregion
+#endif
+
+        #endregion
+
+        #region Complex
+
+#if _REGEN1
+        %foreach supported_primitives%
         
         /// <summary>
-        ///     Converts <see cref="UInt32"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="#1"/> array to a <see cref="Complex"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Complex</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(UInt32[] sourceArray)
+        public static Complex[] ToComplex(#1[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -3964,14 +1371,19 @@ public static Complex[] ToComplex(UInt32[] sourceArray)
             Parallel.For(0, length, i => new Complex(Converts.ToDouble(sourceArray[i]), 0d));
             return output;
         }
+        %
+#else
+
+
+        
         
         /// <summary>
-        ///     Converts <see cref="Int64"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="Boolean"/> array to a <see cref="Complex"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Complex</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(Int64[] sourceArray)
+        public static Complex[] ToComplex(Boolean[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -3984,12 +1396,12 @@ public static Complex[] ToComplex(Int64[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="UInt64"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="Byte"/> array to a <see cref="Complex"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Complex</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(UInt64[] sourceArray)
+        public static Complex[] ToComplex(Byte[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -4002,12 +1414,12 @@ public static Complex[] ToComplex(UInt64[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="Char"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="Int32"/> array to a <see cref="Complex"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Complex</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(Char[] sourceArray)
+        public static Complex[] ToComplex(Int32[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -4020,12 +1432,12 @@ public static Complex[] ToComplex(Char[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="Double"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="Int64"/> array to a <see cref="Complex"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Complex</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(Double[] sourceArray)
+        public static Complex[] ToComplex(Int64[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
@@ -4056,12 +1468,12 @@ public static Complex[] ToComplex(Single[] sourceArray)
         }
         
         /// <summary>
-        ///     Converts <see cref="Decimal"/> array to a <see cref="Complex"/> array.
+        ///     Converts <see cref="Double"/> array to a <see cref="Complex"/> array.
         /// </summary>
         /// <param name="sourceArray">The array to convert</param>
         /// <returns>Converted array of type Complex</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Complex[] ToComplex(Decimal[] sourceArray)
+        public static Complex[] ToComplex(Double[] sourceArray)
         {
             if (sourceArray == null)
                 throw new ArgumentNullException(nameof(sourceArray));
diff --git a/src/NumSharp.Core/Utilities/Arrays.cs b/src/NumSharp.Core/Utilities/Arrays.cs
index c48d61663..a17ed7ac7 100644
--- a/src/NumSharp.Core/Utilities/Arrays.cs
+++ b/src/NumSharp.Core/Utilities/Arrays.cs
@@ -426,7 +426,7 @@ public static Array Create(NPTypeCode typeCode, int length)
         {
             switch (typeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %foreach all_dtypes,all_dtypes_lowercase%
                 case NPTypeCode.#1:
                 {
@@ -436,76 +436,34 @@ public static Array Create(NPTypeCode typeCode, int length)
                 default:
                     throw new NotImplementedException();
 #else
-                case NPTypeCode.Complex:
-                {
-                    return new Complex[length];
-                }
-
                 case NPTypeCode.Boolean:
                 {
                     return new bool[length];
                 }
-
                 case NPTypeCode.Byte:
                 {
                     return new byte[length];
                 }
-
-                case NPTypeCode.Int16:
-                {
-                    return new short[length];
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    return new ushort[length];
-                }
-
                 case NPTypeCode.Int32:
                 {
                     return new int[length];
                 }
-
-                case NPTypeCode.UInt32:
-                {
-                    return new uint[length];
-                }
-
                 case NPTypeCode.Int64:
                 {
                     return new long[length];
                 }
-
-                case NPTypeCode.UInt64:
-                {
-                    return new ulong[length];
-                }
-
-                case NPTypeCode.Char:
-                {
-                    return new char[length];
-                }
-
-                case NPTypeCode.Double:
-                {
-                    return new double[length];
-                }
-
                 case NPTypeCode.Single:
                 {
                     return new float[length];
                 }
-
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
-                    return new decimal[length];
+                    return new double[length];
                 }
-
                 case NPTypeCode.String:
                 {
                     return new string[length];
                 }
-
                 default:
                     throw new NotImplementedException();
 #endif
@@ -522,7 +480,7 @@ public static Array Wrap(NPTypeCode typeCode, object value)
         {
             switch (typeCode)
             {
-#if _REGEN
+#if _REGEN1
                 %foreach all_dtypes,all_dtypes_lowercase%
                 case NPTypeCode.#1:
                 {
@@ -532,76 +490,34 @@ public static Array Wrap(NPTypeCode typeCode, object value)
                 default:
                     throw new NotImplementedException();
 #else
-                case NPTypeCode.Complex:
-                {
-                    return new Complex[1] {(Complex)value};
-                }
-
                 case NPTypeCode.Boolean:
                 {
                     return new bool[1] {(Boolean)value};
                 }
-
                 case NPTypeCode.Byte:
                 {
                     return new byte[1] {(Byte)value};
                 }
-
-                case NPTypeCode.Int16:
-                {
-                    return new short[1] {(Int16)value};
-                }
-
-                case NPTypeCode.UInt16:
-                {
-                    return new ushort[1] {(UInt16)value};
-                }
-
                 case NPTypeCode.Int32:
                 {
                     return new int[1] {(Int32)value};
                 }
-
-                case NPTypeCode.UInt32:
-                {
-                    return new uint[1] {(UInt32)value};
-                }
-
                 case NPTypeCode.Int64:
                 {
                     return new long[1] {(Int64)value};
                 }
-
-                case NPTypeCode.UInt64:
-                {
-                    return new ulong[1] {(UInt64)value};
-                }
-
-                case NPTypeCode.Char:
-                {
-                    return new char[1] {(Char)value};
-                }
-
-                case NPTypeCode.Double:
-                {
-                    return new double[1] {(Double)value};
-                }
-
                 case NPTypeCode.Single:
                 {
                     return new float[1] {(Single)value};
                 }
-
-                case NPTypeCode.Decimal:
+                case NPTypeCode.Double:
                 {
-                    return new decimal[1] {(Decimal)value};
+                    return new double[1] {(Double)value};
                 }
-
                 case NPTypeCode.String:
                 {
                     return new string[1] {(String)value};
                 }
-
                 default:
                     throw new NotImplementedException();
 #endif
diff --git a/src/NumSharp.Core/Utilities/Converts.cs b/src/NumSharp.Core/Utilities/Converts.cs
index 067d35b78..22b077c1b 100644
--- a/src/NumSharp.Core/Utilities/Converts.cs
+++ b/src/NumSharp.Core/Utilities/Converts.cs
@@ -37,28 +37,16 @@ public static TOut ChangeType<TOut>(Object value)
             {
                 case NPTypeCode.Boolean:
                     return (TOut)(object)((IConvertible)value).ToBoolean(CultureInfo.InvariantCulture);
-                case NPTypeCode.Char:
-                    return (TOut)(object)((IConvertible)value).ToChar(CultureInfo.InvariantCulture);
                 case NPTypeCode.Byte:
                     return (TOut)(object)((IConvertible)value).ToByte(CultureInfo.InvariantCulture);
-                case NPTypeCode.Int16:
-                    return (TOut)(object)((IConvertible)value).ToInt16(CultureInfo.InvariantCulture);
-                case NPTypeCode.UInt16:
-                    return (TOut)(object)((IConvertible)value).ToUInt16(CultureInfo.InvariantCulture);
                 case NPTypeCode.Int32:
                     return (TOut)(object)((IConvertible)value).ToInt32(CultureInfo.InvariantCulture);
-                case NPTypeCode.UInt32:
-                    return (TOut)(object)((IConvertible)value).ToUInt32(CultureInfo.InvariantCulture);
                 case NPTypeCode.Int64:
                     return (TOut)(object)((IConvertible)value).ToInt64(CultureInfo.InvariantCulture);
-                case NPTypeCode.UInt64:
-                    return (TOut)(object)((IConvertible)value).ToUInt64(CultureInfo.InvariantCulture);
                 case NPTypeCode.Single:
                     return (TOut)(object)((IConvertible)value).ToSingle(CultureInfo.InvariantCulture);
                 case NPTypeCode.Double:
                     return (TOut)(object)((IConvertible)value).ToDouble(CultureInfo.InvariantCulture);
-                case NPTypeCode.Decimal:
-                    return (TOut)(object)((IConvertible)value).ToDecimal(CultureInfo.InvariantCulture);
                 case NPTypeCode.String:
                     return (TOut)(object)((IConvertible)value).ToString(CultureInfo.InvariantCulture);
                 case NPTypeCode.Empty:
@@ -96,28 +84,16 @@ public static Object ChangeType(Object value, NPTypeCode typeCode)
             {
                 case NPTypeCode.Boolean:
                     return ((IConvertible)value).ToBoolean(CultureInfo.InvariantCulture);
-                case NPTypeCode.Char:
-                    return ((IConvertible)value).ToChar(CultureInfo.InvariantCulture);
                 case NPTypeCode.Byte:
                     return ((IConvertible)value).ToByte(CultureInfo.InvariantCulture);
-                case NPTypeCode.Int16:
-                    return ((IConvertible)value).ToInt16(CultureInfo.InvariantCulture);
-                case NPTypeCode.UInt16:
-                    return ((IConvertible)value).ToUInt16(CultureInfo.InvariantCulture);
                 case NPTypeCode.Int32:
                     return ((IConvertible)value).ToInt32(CultureInfo.InvariantCulture);
-                case NPTypeCode.UInt32:
-                    return ((IConvertible)value).ToUInt32(CultureInfo.InvariantCulture);
                 case NPTypeCode.Int64:
                     return ((IConvertible)value).ToInt64(CultureInfo.InvariantCulture);
-                case NPTypeCode.UInt64:
-                    return ((IConvertible)value).ToUInt64(CultureInfo.InvariantCulture);
                 case NPTypeCode.Single:
                     return ((IConvertible)value).ToSingle(CultureInfo.InvariantCulture);
                 case NPTypeCode.Double:
                     return ((IConvertible)value).ToDouble(CultureInfo.InvariantCulture);
-                case NPTypeCode.Decimal:
-                    return ((IConvertible)value).ToDecimal(CultureInfo.InvariantCulture);
                 case NPTypeCode.String:
                     return ((IConvertible)value).ToString(CultureInfo.InvariantCulture);
                 case NPTypeCode.Empty:
@@ -154,28 +130,16 @@ public static Object ChangeType(Object value, NPTypeCode typeCode, IFormatProvid
             {
                 case NPTypeCode.Boolean:
                     return ((IConvertible)value).ToBoolean(provider);
-                case NPTypeCode.Char:
-                    return ((IConvertible)value).ToChar(provider);
                 case NPTypeCode.Byte:
                     return ((IConvertible)value).ToByte(provider);
-                case NPTypeCode.Int16:
-                    return ((IConvertible)value).ToInt16(provider);
-                case NPTypeCode.UInt16:
-                    return ((IConvertible)value).ToUInt16(provider);
                 case NPTypeCode.Int32:
                     return ((IConvertible)value).ToInt32(provider);
-                case NPTypeCode.UInt32:
-                    return ((IConvertible)value).ToUInt32(provider);
                 case NPTypeCode.Int64:
                     return ((IConvertible)value).ToInt64(provider);
-                case NPTypeCode.UInt64:
-                    return ((IConvertible)value).ToUInt64(provider);
                 case NPTypeCode.Single:
                     return ((IConvertible)value).ToSingle(provider);
                 case NPTypeCode.Double:
                     return ((IConvertible)value).ToDouble(provider);
-                case NPTypeCode.Decimal:
-                    return ((IConvertible)value).ToDecimal(provider);
                 case NPTypeCode.String:
                     return ((IConvertible)value).ToString(provider);
                 case NPTypeCode.Empty:
@@ -193,7 +157,7 @@ public static Object ChangeType(Object value, NPTypeCode typeCode, IFormatProvid
         /// <typeparam name="TOut">The type we expect to convert to.</typeparam>
         public static Func<TIn, TOut> FindConverter<TIn, TOut>()
         {
-#if _REGEN
+#if _REGEN1
             #region Compute
             //#n is input, #10n is output
 		    switch (InfoOf<TIn>.NPTypeCode)
@@ -228,877 +192,268 @@ public static Func<TIn, TOut> FindConverter<TIn, TOut>()
 #else
 
             #region Compute
-
             //#n is input, #10n is output
-            switch (InfoOf<TIn>.NPTypeCode)
-            {
-                case NPTypeCode.Boolean:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<bool, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<bool, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<bool, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<bool, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<bool, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<bool, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<bool, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<bool, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<bool, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<bool, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<bool, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<bool, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
-                        {
-                            var tout = typeof(TOut);
-                            return @in => (TOut)Convert.ChangeType(@in, tout);
-                        }
-                    }
-                }
-                case NPTypeCode.Byte:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<byte, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<byte, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<byte, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<byte, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<byte, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<byte, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<byte, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<byte, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<byte, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<byte, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<byte, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<byte, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
-                        {
-                            var tout = typeof(TOut);
-                            return @in => (TOut)Convert.ChangeType(@in, tout);
-                        }
-                    }
-                }
-                case NPTypeCode.Int16:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<short, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<short, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<short, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<short, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<short, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<short, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<short, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<short, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<short, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<short, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<short, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<short, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
-                        {
-                            var tout = typeof(TOut);
-                            return @in => (TOut)Convert.ChangeType(@in, tout);
-                        }
-                    }
-                }
-                case NPTypeCode.UInt16:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<ushort, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<ushort, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<ushort, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<ushort, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<ushort, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<ushort, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<ushort, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<ushort, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<ushort, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<ushort, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<ushort, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<ushort, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
-                        {
-                            var tout = typeof(TOut);
-                            return @in => (TOut)Convert.ChangeType(@in, tout);
-                        }
-                    }
-                }
-                case NPTypeCode.Int32:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<int, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<int, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<int, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<int, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<int, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<int, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<int, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<int, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<int, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<int, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<int, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<int, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
-                        {
-                            var tout = typeof(TOut);
-                            return @in => (TOut)Convert.ChangeType(@in, tout);
-                        }
-                    }
-                }
-                case NPTypeCode.UInt32:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<uint, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<uint, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<uint, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<uint, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<uint, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<uint, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<uint, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<uint, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<uint, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<uint, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<uint, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<uint, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
-                        {
-                            var tout = typeof(TOut);
-                            return @in => (TOut)Convert.ChangeType(@in, tout);
-                        }
-                    }
-                }
-                case NPTypeCode.Int64:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<long, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<long, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<long, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<long, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<long, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<long, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<long, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<long, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<long, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<long, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<long, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<long, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
-                        {
-                            var tout = typeof(TOut);
-                            return @in => (TOut)Convert.ChangeType(@in, tout);
-                        }
-                    }
-                }
-                case NPTypeCode.UInt64:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<ulong, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<ulong, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<ulong, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<ulong, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<ulong, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<ulong, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<ulong, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<ulong, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<ulong, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<ulong, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<ulong, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<ulong, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
-                        {
-                            var tout = typeof(TOut);
-                            return @in => (TOut)Convert.ChangeType(@in, tout);
-                        }
-                    }
-                }
-                case NPTypeCode.Char:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<char, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<char, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<char, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<char, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<char, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<char, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<char, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<char, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<char, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<char, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<char, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<char, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
-                        {
-                            var tout = typeof(TOut);
-                            return @in => (TOut)Convert.ChangeType(@in, tout);
-                        }
-                    }
-                }
-                case NPTypeCode.Double:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<double, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<double, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<double, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<double, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<double, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<double, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<double, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<double, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<double, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<double, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<double, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<double, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
+		    switch (InfoOf<TIn>.NPTypeCode)
+		    {
+			    case NPTypeCode.Boolean:
+			    {
+				    switch (InfoOf<TOut>.NPTypeCode)
+		            {
+			            case NPTypeCode.Boolean:
+			            {
+				            Func<bool, bool> ret = Converts.ToBoolean;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Byte:
+			            {
+				            Func<bool, byte> ret = Converts.ToByte;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int32:
+			            {
+				            Func<bool, int> ret = Converts.ToInt32;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int64:
+			            {
+				            Func<bool, long> ret = Converts.ToInt64;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Single:
+			            {
+				            Func<bool, float> ret = Converts.ToSingle;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Double:
+			            {
+				            Func<bool, double> ret = Converts.ToDouble;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            default:
                         {
                             var tout = typeof(TOut);
                             return @in => (TOut)Convert.ChangeType(@in, tout);
                         }
-                    }
-                }
-                case NPTypeCode.Single:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<float, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<float, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<float, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<float, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<float, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<float, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<float, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<float, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<float, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
-                        {
-                            Func<float, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Single:
-                        {
-                            Func<float, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Decimal:
-                        {
-                            Func<float, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        default:
+		            }
+			    }
+			    case NPTypeCode.Byte:
+			    {
+				    switch (InfoOf<TOut>.NPTypeCode)
+		            {
+			            case NPTypeCode.Boolean:
+			            {
+				            Func<byte, bool> ret = Converts.ToBoolean;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Byte:
+			            {
+				            Func<byte, byte> ret = Converts.ToByte;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int32:
+			            {
+				            Func<byte, int> ret = Converts.ToInt32;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int64:
+			            {
+				            Func<byte, long> ret = Converts.ToInt64;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Single:
+			            {
+				            Func<byte, float> ret = Converts.ToSingle;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Double:
+			            {
+				            Func<byte, double> ret = Converts.ToDouble;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            default:
                         {
                             var tout = typeof(TOut);
                             return @in => (TOut)Convert.ChangeType(@in, tout);
                         }
-                    }
-                }
-                case NPTypeCode.Decimal:
-                {
-                    switch (InfoOf<TOut>.NPTypeCode)
-                    {
-                        case NPTypeCode.Boolean:
-                        {
-                            Func<decimal, bool> ret = Converts.ToBoolean;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Byte:
-                        {
-                            Func<decimal, byte> ret = Converts.ToByte;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int16:
-                        {
-                            Func<decimal, short> ret = Converts.ToInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt16:
-                        {
-                            Func<decimal, ushort> ret = Converts.ToUInt16;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int32:
-                        {
-                            Func<decimal, int> ret = Converts.ToInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt32:
-                        {
-                            Func<decimal, uint> ret = Converts.ToUInt32;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Int64:
-                        {
-                            Func<decimal, long> ret = Converts.ToInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.UInt64:
-                        {
-                            Func<decimal, ulong> ret = Converts.ToUInt64;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Char:
-                        {
-                            Func<decimal, char> ret = Converts.ToChar;
-                            return (Func<TIn, TOut>)(object)ret;
-                        }
-                        case NPTypeCode.Double:
+		            }
+			    }
+			    case NPTypeCode.Int32:
+			    {
+				    switch (InfoOf<TOut>.NPTypeCode)
+		            {
+			            case NPTypeCode.Boolean:
+			            {
+				            Func<int, bool> ret = Converts.ToBoolean;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Byte:
+			            {
+				            Func<int, byte> ret = Converts.ToByte;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int32:
+			            {
+				            Func<int, int> ret = Converts.ToInt32;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int64:
+			            {
+				            Func<int, long> ret = Converts.ToInt64;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Single:
+			            {
+				            Func<int, float> ret = Converts.ToSingle;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Double:
+			            {
+				            Func<int, double> ret = Converts.ToDouble;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            default:
                         {
-                            Func<decimal, double> ret = Converts.ToDouble;
-                            return (Func<TIn, TOut>)(object)ret;
+                            var tout = typeof(TOut);
+                            return @in => (TOut)Convert.ChangeType(@in, tout);
                         }
-                        case NPTypeCode.Single:
+		            }
+			    }
+			    case NPTypeCode.Int64:
+			    {
+				    switch (InfoOf<TOut>.NPTypeCode)
+		            {
+			            case NPTypeCode.Boolean:
+			            {
+				            Func<long, bool> ret = Converts.ToBoolean;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Byte:
+			            {
+				            Func<long, byte> ret = Converts.ToByte;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int32:
+			            {
+				            Func<long, int> ret = Converts.ToInt32;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int64:
+			            {
+				            Func<long, long> ret = Converts.ToInt64;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Single:
+			            {
+				            Func<long, float> ret = Converts.ToSingle;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Double:
+			            {
+				            Func<long, double> ret = Converts.ToDouble;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            default:
                         {
-                            Func<decimal, float> ret = Converts.ToSingle;
-                            return (Func<TIn, TOut>)(object)ret;
+                            var tout = typeof(TOut);
+                            return @in => (TOut)Convert.ChangeType(@in, tout);
                         }
-                        case NPTypeCode.Decimal:
+		            }
+			    }
+			    case NPTypeCode.Single:
+			    {
+				    switch (InfoOf<TOut>.NPTypeCode)
+		            {
+			            case NPTypeCode.Boolean:
+			            {
+				            Func<float, bool> ret = Converts.ToBoolean;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Byte:
+			            {
+				            Func<float, byte> ret = Converts.ToByte;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int32:
+			            {
+				            Func<float, int> ret = Converts.ToInt32;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int64:
+			            {
+				            Func<float, long> ret = Converts.ToInt64;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Single:
+			            {
+				            Func<float, float> ret = Converts.ToSingle;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Double:
+			            {
+				            Func<float, double> ret = Converts.ToDouble;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            default:
                         {
-                            Func<decimal, decimal> ret = Converts.ToDecimal;
-                            return (Func<TIn, TOut>)(object)ret;
+                            var tout = typeof(TOut);
+                            return @in => (TOut)Convert.ChangeType(@in, tout);
                         }
-                        default:
+		            }
+			    }
+			    case NPTypeCode.Double:
+			    {
+				    switch (InfoOf<TOut>.NPTypeCode)
+		            {
+			            case NPTypeCode.Boolean:
+			            {
+				            Func<double, bool> ret = Converts.ToBoolean;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Byte:
+			            {
+				            Func<double, byte> ret = Converts.ToByte;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int32:
+			            {
+				            Func<double, int> ret = Converts.ToInt32;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Int64:
+			            {
+				            Func<double, long> ret = Converts.ToInt64;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Single:
+			            {
+				            Func<double, float> ret = Converts.ToSingle;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            case NPTypeCode.Double:
+			            {
+				            Func<double, double> ret = Converts.ToDouble;
+                            return (Func<TIn, TOut>) (object) ret;
+			            }
+			            default:
                         {
                             var tout = typeof(TOut);
                             return @in => (TOut)Convert.ChangeType(@in, tout);
                         }
-                    }
-                }
-                default:
+		            }
+			    }
+			    default:
                 {
                     var tout = typeof(TOut);
                     return @in => (TOut)Convert.ChangeType(@in, tout);
                 }
-            }
-
+		    }
             #endregion
-
 #endif
         }
 
         #region ToScalar
 
-#if _REGEN
+#if _REGEN1
         #region Compute
 
 		%foreach supported_dtypes,supported_dtypes_lowercase%
@@ -1117,7 +472,7 @@ public static Func<TIn, TOut> FindConverter<TIn, TOut>()
 
         #region Compute
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool ToBoolean(NDArray nd)
         {
             if (nd.size != 1)
@@ -1125,8 +480,7 @@ public static bool ToBoolean(NDArray nd)
 
             return nd.typecode == NPTypeCode.Boolean ? nd.GetAtIndex<bool>(0) : Converts.ToBoolean(nd.GetAtIndex(0));
         }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static byte ToByte(NDArray nd)
         {
             if (nd.size != 1)
@@ -1134,26 +488,7 @@ public static byte ToByte(NDArray nd)
 
             return nd.typecode == NPTypeCode.Byte ? nd.GetAtIndex<byte>(0) : Converts.ToByte(nd.GetAtIndex(0));
         }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static short ToInt16(NDArray nd)
-        {
-            if (nd.size != 1)
-                throw new IncorrectSizeException("Unable to convert NDArray to scalar because size is not 1.");
-
-            return nd.typecode == NPTypeCode.Int16 ? nd.GetAtIndex<short>(0) : Converts.ToInt16(nd.GetAtIndex(0));
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ushort ToUInt16(NDArray nd)
-        {
-            if (nd.size != 1)
-                throw new IncorrectSizeException("Unable to convert NDArray to scalar because size is not 1.");
-
-            return nd.typecode == NPTypeCode.UInt16 ? nd.GetAtIndex<ushort>(0) : Converts.ToUInt16(nd.GetAtIndex(0));
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int ToInt32(NDArray nd)
         {
             if (nd.size != 1)
@@ -1161,17 +496,7 @@ public static int ToInt32(NDArray nd)
 
             return nd.typecode == NPTypeCode.Int32 ? nd.GetAtIndex<int>(0) : Converts.ToInt32(nd.GetAtIndex(0));
         }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint ToUInt32(NDArray nd)
-        {
-            if (nd.size != 1)
-                throw new IncorrectSizeException("Unable to convert NDArray to scalar because size is not 1.");
-
-            return nd.typecode == NPTypeCode.UInt32 ? nd.GetAtIndex<uint>(0) : Converts.ToUInt32(nd.GetAtIndex(0));
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static long ToInt64(NDArray nd)
         {
             if (nd.size != 1)
@@ -1179,35 +504,7 @@ public static long ToInt64(NDArray nd)
 
             return nd.typecode == NPTypeCode.Int64 ? nd.GetAtIndex<long>(0) : Converts.ToInt64(nd.GetAtIndex(0));
         }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong ToUInt64(NDArray nd)
-        {
-            if (nd.size != 1)
-                throw new IncorrectSizeException("Unable to convert NDArray to scalar because size is not 1.");
-
-            return nd.typecode == NPTypeCode.UInt64 ? nd.GetAtIndex<ulong>(0) : Converts.ToUInt64(nd.GetAtIndex(0));
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static char ToChar(NDArray nd)
-        {
-            if (nd.size != 1)
-                throw new IncorrectSizeException("Unable to convert NDArray to scalar because size is not 1.");
-
-            return nd.typecode == NPTypeCode.Char ? nd.GetAtIndex<char>(0) : Converts.ToChar(nd.GetAtIndex(0));
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double ToDouble(NDArray nd)
-        {
-            if (nd.size != 1)
-                throw new IncorrectSizeException("Unable to convert NDArray to scalar because size is not 1.");
-
-            return nd.typecode == NPTypeCode.Double ? nd.GetAtIndex<double>(0) : Converts.ToDouble(nd.GetAtIndex(0));
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float ToSingle(NDArray nd)
         {
             if (nd.size != 1)
@@ -1215,18 +512,16 @@ public static float ToSingle(NDArray nd)
 
             return nd.typecode == NPTypeCode.Single ? nd.GetAtIndex<float>(0) : Converts.ToSingle(nd.GetAtIndex(0));
         }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal ToDecimal(NDArray nd)
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double ToDouble(NDArray nd)
         {
             if (nd.size != 1)
                 throw new IncorrectSizeException("Unable to convert NDArray to scalar because size is not 1.");
 
-            return nd.typecode == NPTypeCode.Decimal ? nd.GetAtIndex<decimal>(0) : Converts.ToDecimal(nd.GetAtIndex(0));
+            return nd.typecode == NPTypeCode.Double ? nd.GetAtIndex<double>(0) : Converts.ToDouble(nd.GetAtIndex(0));
         }
-
+			    
         #endregion
-
 #endif
 
         #endregion
diff --git a/src/NumSharp.Core/Utilities/Converts`1.cs b/src/NumSharp.Core/Utilities/Converts`1.cs
index 4522f172e..565a34cd1 100644
--- a/src/NumSharp.Core/Utilities/Converts`1.cs
+++ b/src/NumSharp.Core/Utilities/Converts`1.cs
@@ -17,7 +17,7 @@ static Converts()
         
         #region Cached Converters
 
-#if _REGEN
+#if _REGEN1
         #region Compute
 		%foreach supported_dtypes,supported_dtypes_lowercase%
         /// <summary>
@@ -40,139 +40,62 @@ static Converts()
 #else
 
         #region Compute
-
         /// <summary>
-        ///     Converts <typeparamref name="T"/> to <see cref="bool"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
+        ///     Converts <typeparamref name="T"/> to <see cref="Boolean"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
         /// </summary>
-        /// <param name="obj">The object to convert to <see cref="bool"/></param>
-        /// <returns>A <see cref="bool"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool ToBoolean(T obj) => _toBoolean(obj);
-
-        private static readonly Func<T, bool> _toBoolean = Converts.FindConverter<T, bool>();
+        /// <param name="obj">The object to convert to <see cref="Boolean"/></param>
+        /// <returns>A <see cref="Boolean"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool ToBoolean(T obj) => _toBoolean(obj);
+		private static readonly Func<T, bool> _toBoolean = Converts.FindConverter<T, bool>();
 
         /// <summary>
         ///     Converts <typeparamref name="T"/> to <see cref="Byte"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
         /// </summary>
         /// <param name="obj">The object to convert to <see cref="Byte"/></param>
         /// <returns>A <see cref="Byte"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static byte ToByte(T obj) => _toByte(obj);
-
-        private static readonly Func<T, byte> _toByte = Converts.FindConverter<T, byte>();
-
-        /// <summary>
-        ///     Converts <typeparamref name="T"/> to <see cref="Int16"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
-        /// </summary>
-        /// <param name="obj">The object to convert to <see cref="Int16"/></param>
-        /// <returns>A <see cref="Int16"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static short ToInt16(T obj) => _toInt16(obj);
-
-        private static readonly Func<T, short> _toInt16 = Converts.FindConverter<T, short>();
-
-        /// <summary>
-        ///     Converts <typeparamref name="T"/> to <see cref="UInt16"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
-        /// </summary>
-        /// <param name="obj">The object to convert to <see cref="UInt16"/></param>
-        /// <returns>A <see cref="UInt16"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ushort ToUInt16(T obj) => _toUInt16(obj);
-
-        private static readonly Func<T, ushort> _toUInt16 = Converts.FindConverter<T, ushort>();
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] public static byte ToByte(T obj) => _toByte(obj);
+		private static readonly Func<T, byte> _toByte = Converts.FindConverter<T, byte>();
 
         /// <summary>
         ///     Converts <typeparamref name="T"/> to <see cref="Int32"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
         /// </summary>
         /// <param name="obj">The object to convert to <see cref="Int32"/></param>
         /// <returns>A <see cref="Int32"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int ToInt32(T obj) => _toInt32(obj);
-
-        private static readonly Func<T, int> _toInt32 = Converts.FindConverter<T, int>();
-
-        /// <summary>
-        ///     Converts <typeparamref name="T"/> to <see cref="UInt32"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
-        /// </summary>
-        /// <param name="obj">The object to convert to <see cref="UInt32"/></param>
-        /// <returns>A <see cref="UInt32"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint ToUInt32(T obj) => _toUInt32(obj);
-
-        private static readonly Func<T, uint> _toUInt32 = Converts.FindConverter<T, uint>();
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] public static int ToInt32(T obj) => _toInt32(obj);
+		private static readonly Func<T, int> _toInt32 = Converts.FindConverter<T, int>();
 
         /// <summary>
         ///     Converts <typeparamref name="T"/> to <see cref="Int64"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
         /// </summary>
         /// <param name="obj">The object to convert to <see cref="Int64"/></param>
         /// <returns>A <see cref="Int64"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long ToInt64(T obj) => _toInt64(obj);
-
-        private static readonly Func<T, long> _toInt64 = Converts.FindConverter<T, long>();
-
-        /// <summary>
-        ///     Converts <typeparamref name="T"/> to <see cref="UInt64"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
-        /// </summary>
-        /// <param name="obj">The object to convert to <see cref="UInt64"/></param>
-        /// <returns>A <see cref="UInt64"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong ToUInt64(T obj) => _toUInt64(obj);
-
-        private static readonly Func<T, ulong> _toUInt64 = Converts.FindConverter<T, ulong>();
-
-        /// <summary>
-        ///     Converts <typeparamref name="T"/> to <see cref="Char"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
-        /// </summary>
-        /// <param name="obj">The object to convert to <see cref="Char"/></param>
-        /// <returns>A <see cref="Char"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static char ToChar(T obj) => _toChar(obj);
-
-        private static readonly Func<T, char> _toChar = Converts.FindConverter<T, char>();
-
-        /// <summary>
-        ///     Converts <typeparamref name="T"/> to <see cref="Double"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
-        /// </summary>
-        /// <param name="obj">The object to convert to <see cref="Double"/></param>
-        /// <returns>A <see cref="Double"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double ToDouble(T obj) => _toDouble(obj);
-
-        private static readonly Func<T, double> _toDouble = Converts.FindConverter<T, double>();
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] public static long ToInt64(T obj) => _toInt64(obj);
+		private static readonly Func<T, long> _toInt64 = Converts.FindConverter<T, long>();
 
         /// <summary>
         ///     Converts <typeparamref name="T"/> to <see cref="Single"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
         /// </summary>
         /// <param name="obj">The object to convert to <see cref="Single"/></param>
         /// <returns>A <see cref="Single"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float ToSingle(T obj) => _toSingle(obj);
-
-        private static readonly Func<T, float> _toSingle = Converts.FindConverter<T, float>();
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] public static float ToSingle(T obj) => _toSingle(obj);
+		private static readonly Func<T, float> _toSingle = Converts.FindConverter<T, float>();
 
         /// <summary>
-        ///     Converts <typeparamref name="T"/> to <see cref="Decimal"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
+        ///     Converts <typeparamref name="T"/> to <see cref="Double"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
         /// </summary>
-        /// <param name="obj">The object to convert to <see cref="Decimal"/></param>
-        /// <returns>A <see cref="Decimal"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal ToDecimal(T obj) => _toDecimal(obj);
-
-        private static readonly Func<T, decimal> _toDecimal = Converts.FindConverter<T, decimal>();
+        /// <param name="obj">The object to convert to <see cref="Double"/></param>
+        /// <returns>A <see cref="Double"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] public static double ToDouble(T obj) => _toDouble(obj);
+		private static readonly Func<T, double> _toDouble = Converts.FindConverter<T, double>();
 
         /// <summary>
         ///     Converts <typeparamref name="T"/> to <see cref="String"/> using staticly cached <see cref="Converts.FindConverter{TIn,TOut}"/>.
         /// </summary>
         /// <param name="obj">The object to convert to <see cref="String"/></param>
         /// <returns>A <see cref="String"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static String ToString(T obj) => _toString(obj);
-
-        private static readonly Func<T, string> _toString = Converts.FindConverter<T, string>();
-
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] public static String ToString(T obj) => _toString(obj);
+		private static readonly Func<T, string> _toString = Converts.FindConverter<T, string>();
         #endregion
-
 #endif
 
 #if _REGEN
diff --git a/src/NumSharp.Core/Utilities/NumberInfo.cs b/src/NumSharp.Core/Utilities/NumberInfo.cs
index f57b9089a..6512b20e0 100644
--- a/src/NumSharp.Core/Utilities/NumberInfo.cs
+++ b/src/NumSharp.Core/Utilities/NumberInfo.cs
@@ -25,26 +25,14 @@ public static object MaxValue(this NPTypeCode typeCode)
 #else
                 case NPTypeCode.Byte:
                     return Byte.MaxValue;
-                case NPTypeCode.Int16:
-                    return Int16.MaxValue;
-                case NPTypeCode.UInt16:
-                    return UInt16.MaxValue;
                 case NPTypeCode.Int32:
                     return Int32.MaxValue;
-                case NPTypeCode.UInt32:
-                    return UInt32.MaxValue;
                 case NPTypeCode.Int64:
                     return Int64.MaxValue;
-                case NPTypeCode.UInt64:
-                    return UInt64.MaxValue;
-                case NPTypeCode.Char:
-                    return Char.MaxValue;
-                case NPTypeCode.Double:
-                    return Double.MaxValue;
                 case NPTypeCode.Single:
                     return Single.MaxValue;
-                case NPTypeCode.Decimal:
-                    return Decimal.MaxValue;
+                case NPTypeCode.Double:
+                    return Double.MaxValue;
 #endif
                 default:
                     throw new ArgumentOutOfRangeException(nameof(typeCode), typeCode, null);
@@ -62,7 +50,7 @@ public static object MinValue(this NPTypeCode typeCode)
                     return new Complex(double.MinValue, double.MinValue);
                 case NPTypeCode.Boolean:
                     return false;
-#if _REGEN
+#if _REGEN1
 	            %foreach except(supported_primitives, "Boolean", "String")%
                 case NPTypeCode.#1:
                     return #1.MinValue;
@@ -70,26 +58,14 @@ public static object MinValue(this NPTypeCode typeCode)
 #else
                 case NPTypeCode.Byte:
                     return Byte.MinValue;
-                case NPTypeCode.Int16:
-                    return Int16.MinValue;
-                case NPTypeCode.UInt16:
-                    return UInt16.MinValue;
                 case NPTypeCode.Int32:
                     return Int32.MinValue;
-                case NPTypeCode.UInt32:
-                    return UInt32.MinValue;
                 case NPTypeCode.Int64:
                     return Int64.MinValue;
-                case NPTypeCode.UInt64:
-                    return UInt64.MinValue;
-                case NPTypeCode.Char:
-                    return Char.MinValue;
-                case NPTypeCode.Double:
-                    return Double.MinValue;
                 case NPTypeCode.Single:
                     return Single.MinValue;
-                case NPTypeCode.Decimal:
-                    return Decimal.MinValue;
+                case NPTypeCode.Double:
+                    return Double.MinValue;
 #endif
                 default:
                     throw new ArgumentOutOfRangeException(nameof(typeCode), typeCode, null);
diff --git a/src/NumSharp.Core/globals.regen b/src/NumSharp.Core/globals.regen
index c976f8cae..90dea795b 100644
--- a/src/NumSharp.Core/globals.regen
+++ b/src/NumSharp.Core/globals.regen
@@ -1,33 +1,33 @@
-%all_dtypes = ["NDArray","Complex","Boolean","Byte","Int16","UInt16","Int32","UInt32","Int64","UInt64","Char","Double","Single","Decimal","String"]
-%all_dtypes_lowercase = ["NDArray","Complex","bool","byte","short","ushort","int","uint","long","ulong","char","double","float","decimal","string"]
+%all_dtypes = ["Boolean","Byte","Int32","Int64","Single","Double","String"]
+%all_dtypes_lowercase = ["bool","byte","int","long","float","double","string"]
 
-%supported_primitives = ["Boolean","Byte","Int16","UInt16","Int32","UInt32","Int64","UInt64","Char","Double","Single","Decimal","String"]
-%supported_primitives_lowercase = ["bool","byte","short","ushort","int","uint","long","ulong","char","double","float","decimal","string"]
+%supported_primitives = ["Boolean","Byte","Int32","Int64","Single","Double","String"]
+%supported_primitives_lowercase = ["bool","byte","int","long","float","double","string"]
 
-%supported_numericals = ["Byte","Int16","UInt16","Int32","UInt32","Int64","UInt64","Char","Double","Single","Decimal"]
-%supported_numericals_lowercase = ["byte","short","ushort","int","uint","long","ulong","char","double","float","decimal"]
-%supported_numericals_defaultvals = ["0","0","0","0","0u","0L","0UL","'\0'","0d","0f","0m"]
-%supported_numericals_onevales = ["1","1","1","1","1u","1L","1UL",1,"1d","1f","1m"]
-//this is the type we use in summerizing/reducting:
-%supported_numericals_accumulatingType = ["UInt32","Int32","UInt32","Int32","UInt32","Int64","UInt64","UInt32","Double","Single","Decimal"]
-%supported_numericals_accumulatingType_defaultvals = ["0","0","0","0","0u","0L","0UL","'\0'","0d","0f","0m"]
+%supported_numericals = ["Byte","Int32","Int64","Single","Double"]
+%supported_numericals_lowercase = ["byte","int","long","float","double"]
+%supported_numericals_defaultvals = ["0","0","0L","0f","0d"]
+%supported_numericals_onevales = ["1","1","1L","1f","1d"]
 
-%supported_numericals_signed = ["Int16","Int32","Int64","Double","Single","Decimal"]
-%supported_numericals_signed_lowercase = ["short","int","long","double","float","decimal"]
-%supported_numericals_signed_defaultvals = ["0","0","0L","0d","0f","0m"]
-%supported_numericals_signed_onevales = ["1","1","1L","1d","1f","1m"]
+//this is the type we use in summerizing/reducting:
+%supported_numericals_accumulatingType = ["Byte","Int32","Int64","Single","Double"]
+%supported_numericals_accumulatingType_defaultvals = ["0","0","0L","0f","0d"]
+//this is the type we use in summerizing/reducting:
+%supported_dtypes_accumulatingType = ["Byte","Int32","Int64","Single","Double"]
+%supported_dtypes_accumulatingType_defaultvals = ["0","0","0L","0f","0d"]
 
-%supported_numericals_unsigned = ["Byte","UInt16","UInt32","UInt64","Char"]
-%supported_numericals_unsigned_lowercase = ["byte","ushort","uint","ulong","char"]
-%supported_numericals_unsigned_defaultvals = ["0","0","0U","0UL","'\0'"]
-%supported_numericals_unsigned_onevales = ["1","1","1U","1UL","'\1'"]
+%supported_numericals_signed = ["Byte","Int32","Int64","Single","Double"]
+%supported_numericals_signed_lowercase = ["byte","int","long","float","double"]
+%supported_numericals_signed_defaultvals = ["0","0","0L","0f","0d"]
+%supported_numericals_signed_onevales = ["1","1","1L","1f","1d"]
 
-%supported_dtypes = ["Boolean","Byte","Int16","UInt16","Int32","UInt32","Int64","UInt64","Char","Double","Single","Decimal"]
-%supported_dtypes_lowercase = ["bool","byte","short","ushort","int","uint","long","ulong","char","double","float","decimal"]
-%supported_dtypes_defaultvals = [false,"0","0","0","0","0u","0L","0UL","'\0'","0d","0f","0m"]
-%supported_dtypes_onevales = [true,"1","1","1","1","1u","1L","1UL","'\1'","1d","1f","1m"]
-%supported_dtypes_dtype = ["bool","uint8","int16","uint16","int32","uint32","int64","uint64","uint8","float64","float32","float64"]
+%supported_numericals_unsigned = ["Byte","UInt16","UInt32","UInt64"]
+%supported_numericals_unsigned_lowercase = ["byte","ushort","uint","ulong"]
+%supported_numericals_unsigned_defaultvals = ["0","0","0U","0UL"]
+%supported_numericals_unsigned_onevales = ["1","1","1U","1UL"]
 
-//this is the type we use in summerizing/reducting:
-%supported_dtypes_accumulatingType = ["Int32","UInt32","Int32","UInt32","Int32","UInt32","Int64","UInt64","UInt32","Double","Single","Decimal"]
-%supported_dtypes_accumulatingType_defaultvals = [false, "0","0","0","0u","0L","0UL","'\0'","0d","0f","0m"]
\ No newline at end of file
+%supported_dtypes = ["Boolean","Byte","Int32","Int64","Single","Double"]
+%supported_dtypes_lowercase = ["bool","byte","int","long","float","double"]
+%supported_dtypes_defaultvals = [false,"0","0","0L","0f","0d"]
+%supported_dtypes_onevales = [true,"1","1","1L","1f","1d"]
+%supported_dtypes_dtype = ["bool","int8","int32","int64","float32","float64"]
\ No newline at end of file
diff --git a/test/NumSharp.UnitTest/APIs/np.tofromfile.Test.cs b/test/NumSharp.UnitTest/APIs/np.tofromfile.Test.cs
index 2376d961b..68b447319 100644
--- a/test/NumSharp.UnitTest/APIs/np.tofromfile.Test.cs
+++ b/test/NumSharp.UnitTest/APIs/np.tofromfile.Test.cs
@@ -28,6 +28,7 @@ public void NumpyToFromFileTestByte1()
             AssertAreEqual(rawData, loadedArray.Array);
         }
 
+        [Ignore("not support uint16")]
         [TestMethod]
         public void NumpyToFromFileTestUShort1()
         {
diff --git a/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_add_tests.cs b/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_add_tests.cs
index 56a4e51df..df8442a0a 100644
--- a/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_add_tests.cs
+++ b/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_add_tests.cs
@@ -49,16 +49,10 @@ public void Add()
 #else
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Boolean)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Byte)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Int16)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt16)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int32)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt32)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Char)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Single)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Decimal)]
+        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
 #endif
         [DataTestMethod]
         public void AddAllPossabilitiesBoolean(NPTypeCode ltc, NPTypeCode rtc)
@@ -269,8 +263,8 @@ public void Add_LeftScalar_Rising()
 
 
 #if _REGEN
-        %a = ["Boolean","Byte","Int16","UInt16","Int32","UInt32","Int64","UInt64","Double","Single","Decimal"]
-        %b = [true,"1","1","1","1","1u","1L","1UL","1d","1f","1m"]
+        %a = ["Boolean","Byte","Int32","Int64","Double","Single"]
+        %b = [true,"1","1","1L","1d","1f"]
         %foreach forevery(a,a,true), forevery(b,b,true)%
         [TestMethod]
         public void Add_#1_To_#2()
@@ -304,34 +298,6 @@ public void Add_Boolean_To_Byte()
             }
         }
         [TestMethod]
-        public void Add_Boolean_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Boolean_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Add_Boolean_To_Int32()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean);
@@ -346,20 +312,6 @@ public void Add_Boolean_To_Int32()
             }
         }
         [TestMethod]
-        public void Add_Boolean_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt32)1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Add_Boolean_To_Int64()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean);
@@ -374,20 +326,6 @@ public void Add_Boolean_To_Int64()
             }
         }
         [TestMethod]
-        public void Add_Boolean_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt64)1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Add_Boolean_To_Double()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean);
@@ -416,20 +354,6 @@ public void Add_Boolean_To_Single()
             }
         }
         [TestMethod]
-        public void Add_Boolean_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Decimal)1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Add_Byte_To_Boolean()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte);
@@ -444,34 +368,6 @@ public void Add_Byte_To_Boolean()
             }
         }
         [TestMethod]
-        public void Add_Byte_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Byte_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Add_Byte_To_Int32()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte);
@@ -486,20 +382,6 @@ public void Add_Byte_To_Int32()
             }
         }
         [TestMethod]
-        public void Add_Byte_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt32)1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Add_Byte_To_Int64()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte);
@@ -514,20 +396,6 @@ public void Add_Byte_To_Int64()
             }
         }
         [TestMethod]
-        public void Add_Byte_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt64)1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Add_Byte_To_Double()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte);
@@ -556,23 +424,9 @@ public void Add_Byte_To_Single()
             }
         }
         [TestMethod]
-        public void Add_Byte_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Decimal)1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int16_To_Boolean()
+        public void Add_Int32_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left + right;
 
@@ -584,9 +438,9 @@ public void Add_Int16_To_Boolean()
             }
         }
         [TestMethod]
-        public void Add_Int16_To_Byte()
+        public void Add_Int32_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
             var ret = left + right;
 
@@ -598,51 +452,9 @@ public void Add_Int16_To_Byte()
             }
         }
         [TestMethod]
-        public void Add_Int16_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int16_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int32)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int16_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt32)1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int16_To_Int64()
+        public void Add_Int32_To_Int64()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
             var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
             var ret = left + right;
 
@@ -654,23 +466,9 @@ public void Add_Int16_To_Int64()
             }
         }
         [TestMethod]
-        public void Add_Int16_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt64)1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int16_To_Double()
+        public void Add_Int32_To_Double()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
             var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
             var ret = left + right;
 
@@ -682,9 +480,9 @@ public void Add_Int16_To_Double()
             }
         }
         [TestMethod]
-        public void Add_Int16_To_Single()
+        public void Add_Int32_To_Single()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
             var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
             var ret = left + right;
 
@@ -696,23 +494,9 @@ public void Add_Int16_To_Single()
             }
         }
         [TestMethod]
-        public void Add_Int16_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Decimal)1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt16_To_Boolean()
+        public void Add_Int64_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left + right;
 
@@ -724,9 +508,9 @@ public void Add_UInt16_To_Boolean()
             }
         }
         [TestMethod]
-        public void Add_UInt16_To_Byte()
+        public void Add_Int64_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
             var ret = left + right;
 
@@ -738,121 +522,121 @@ public void Add_UInt16_To_Byte()
             }
         }
         [TestMethod]
-        public void Add_UInt16_To_Int16()
+        public void Add_Int64_To_Int32()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
             var ret = left + right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be((Int16)1);
+                val.Should().Be((Int32)1);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Add_UInt16_To_Int32()
+        public void Add_Int64_To_Double()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
             var ret = left + right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be((Int32)1);
+                val.Should().Be((Double)1d);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Add_UInt16_To_UInt32()
+        public void Add_Int64_To_Single()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
             var ret = left + right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt32)1u);
+                val.Should().Be((Single)1f);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Add_UInt16_To_Int64()
+        public void Add_Double_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left + right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be((Int64)1L);
+                val.Should().Be((Boolean)true);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Add_UInt16_To_UInt64()
+        public void Add_Double_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
             var ret = left + right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt64)1UL);
+                val.Should().Be((Byte)1);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Add_UInt16_To_Double()
+        public void Add_Double_To_Int32()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
             var ret = left + right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be((Double)1d);
+                val.Should().Be((Int32)1);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Add_UInt16_To_Single()
+        public void Add_Double_To_Int64()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
             var ret = left + right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be((Single)1f);
+                val.Should().Be((Int64)1L);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Add_UInt16_To_Decimal()
+        public void Add_Double_To_Single()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
             var ret = left + right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be((Decimal)1m);
+                val.Should().Be((Single)1f);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Add_Int32_To_Boolean()
+        public void Add_Single_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left + right;
 
@@ -864,9 +648,9 @@ public void Add_Int32_To_Boolean()
             }
         }
         [TestMethod]
-        public void Add_Int32_To_Byte()
+        public void Add_Single_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
             var ret = left + right;
 
@@ -878,738 +662,10 @@ public void Add_Int32_To_Byte()
             }
         }
         [TestMethod]
-        public void Add_Int32_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int32_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int32_To_UInt32()
+        public void Add_Single_To_Int32()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt32)1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int32_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int64)1L);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int32_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt64)1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int32_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Double)1d);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int32_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Single)1f);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int32_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Decimal)1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt32_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Boolean)true);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt32_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Byte)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt32_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt32_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt32_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int32)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt32_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int64)1L);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt32_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt64)1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt32_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Double)1d);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt32_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Single)1f);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt32_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Decimal)1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int64_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Boolean)true);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int64_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Byte)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int64_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int64_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int64_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int32)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int64_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt32)1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int64_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt64)1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int64_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Double)1d);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int64_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Single)1f);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Int64_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Decimal)1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt64_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Boolean)true);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt64_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Byte)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt64_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt64_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt64_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int32)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt64_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt32)1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt64_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int64)1L);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt64_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Double)1d);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt64_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Single)1f);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_UInt64_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Decimal)1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Double_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Boolean)true);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Double_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Byte)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Double_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Double_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Double_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int32)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Double_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt32)1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Double_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int64)1L);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Double_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt64)1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Double_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Single)1f);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Double_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Decimal)1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Single_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Boolean)true);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Single_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Byte)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Single_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Single_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt16)1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Single_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
             var ret = left + right;
 
             for (int i = 0; i < ret.size; i++)
@@ -1619,48 +675,6 @@ public void Add_Single_To_Int32()
                 Console.WriteLine(val);
             }
         }
-        [TestMethod]
-        public void Add_Single_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt32)1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Single_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((Int64)1L);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Add_Single_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single);
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left + right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be((UInt64)1UL);
-                Console.WriteLine(val);
-            }
-        }
 #endif
     }
 }
diff --git a/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_divide_tests.cs b/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_divide_tests.cs
index d616cebf5..ca7d6b0ec 100644
--- a/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_divide_tests.cs
+++ b/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_divide_tests.cs
@@ -49,16 +49,10 @@ public void Divide()
 #else
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Boolean)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Byte)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Int16)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt16)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int32)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt32)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Char)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Single)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Decimal)]
+        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
 #endif
         [DataTestMethod]
         public void DivideAllPossabilitiesBoolean(NPTypeCode ltc, NPTypeCode rtc)
@@ -82,16 +76,10 @@ public void DivideAllPossabilitiesBoolean(NPTypeCode ltc, NPTypeCode rtc)
 #else
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Boolean)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Byte)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Int16)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt16)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int32)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt32)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Char)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Single)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Decimal)]
+        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
 #endif
         [DataTestMethod]
         public void DivideAllPossabilitiesBoolean_Left(NPTypeCode ltc, NPTypeCode rtc)
@@ -324,8 +312,8 @@ public void Divide_LeftScalar_Rising()
 
 
 #if _REGEN
-        %a = ["Boolean","Byte","Int16","UInt16","Int32","UInt32","Int64","UInt64","Double","Single","Decimal"]
-        %b = [true,"1","1","1","1","1u","1L","1UL","1d","1f","1m"]
+        %a = ["Boolean","Byte","Int32","Int64","Double","Single"]
+        %b = [true,"1","1","1L","1d","1f"]
         %foreach forevery(a,a,true), forevery(b,b,true)%
         [TestMethod]
         public void Divide_#1_To_#2()
@@ -359,34 +347,6 @@ public void Divide_Boolean_To_Byte()
             }
         }
         [TestMethod]
-        public void Divide_Boolean_To_Int16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Boolean_To_UInt16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Divide_Boolean_To_Int32()
         {
             var left = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 3;
@@ -401,20 +361,6 @@ public void Divide_Boolean_To_Int32()
             }
         }
         [TestMethod]
-        public void Divide_Boolean_To_UInt32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Divide_Boolean_To_Int64()
         {
             var left = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 3;
@@ -429,20 +375,6 @@ public void Divide_Boolean_To_Int64()
             }
         }
         [TestMethod]
-        public void Divide_Boolean_To_UInt64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Divide_Boolean_To_Double()
         {
             var left = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 3;
@@ -471,20 +403,6 @@ public void Divide_Boolean_To_Single()
             }
         }
         [TestMethod]
-        public void Divide_Boolean_To_Decimal()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Divide_Byte_To_Boolean()
         {
             var left = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -499,34 +417,6 @@ public void Divide_Byte_To_Boolean()
             }
         }
         [TestMethod]
-        public void Divide_Byte_To_Int16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Byte_To_UInt16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Divide_Byte_To_Int32()
         {
             var left = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -541,20 +431,6 @@ public void Divide_Byte_To_Int32()
             }
         }
         [TestMethod]
-        public void Divide_Byte_To_UInt32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Divide_Byte_To_Int64()
         {
             var left = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -569,20 +445,6 @@ public void Divide_Byte_To_Int64()
             }
         }
         [TestMethod]
-        public void Divide_Byte_To_UInt64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Divide_Byte_To_Double()
         {
             var left = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -611,23 +473,9 @@ public void Divide_Byte_To_Single()
             }
         }
         [TestMethod]
-        public void Divide_Byte_To_Decimal()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int16_To_Boolean()
+        public void Divide_Int32_To_Boolean()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
             var ret = left / right;
             
@@ -639,9 +487,9 @@ public void Divide_Int16_To_Boolean()
             }
         }
         [TestMethod]
-        public void Divide_Int16_To_Byte()
+        public void Divide_Int32_To_Byte()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
             var ret = left / right;
             
@@ -653,51 +501,9 @@ public void Divide_Int16_To_Byte()
             }
         }
         [TestMethod]
-        public void Divide_Int16_To_UInt16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int16_To_Int32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int16_To_UInt32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int16_To_Int64()
+        public void Divide_Int32_To_Int64()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
             var ret = left / right;
             
@@ -709,23 +515,9 @@ public void Divide_Int16_To_Int64()
             }
         }
         [TestMethod]
-        public void Divide_Int16_To_UInt64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int16_To_Double()
+        public void Divide_Int32_To_Double()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
             var ret = left / right;
             
@@ -737,9 +529,9 @@ public void Divide_Int16_To_Double()
             }
         }
         [TestMethod]
-        public void Divide_Int16_To_Single()
+        public void Divide_Int32_To_Single()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
             var ret = left / right;
             
@@ -751,23 +543,9 @@ public void Divide_Int16_To_Single()
             }
         }
         [TestMethod]
-        public void Divide_Int16_To_Decimal()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt16_To_Boolean()
+        public void Divide_Int64_To_Boolean()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 3;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
             var ret = left / right;
             
@@ -779,9 +557,9 @@ public void Divide_UInt16_To_Boolean()
             }
         }
         [TestMethod]
-        public void Divide_UInt16_To_Byte()
+        public void Divide_Int64_To_Byte()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 3;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
             var ret = left / right;
             
@@ -793,10 +571,10 @@ public void Divide_UInt16_To_Byte()
             }
         }
         [TestMethod]
-        public void Divide_UInt16_To_Int16()
+        public void Divide_Int64_To_Int32()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
             var ret = left / right;
             
             for (int i = 0; i < ret.size; i++)
@@ -807,10 +585,10 @@ public void Divide_UInt16_To_Int16()
             }
         }
         [TestMethod]
-        public void Divide_UInt16_To_Int32()
+        public void Divide_Int64_To_Double()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
             var ret = left / right;
             
             for (int i = 0; i < ret.size; i++)
@@ -821,10 +599,10 @@ public void Divide_UInt16_To_Int32()
             }
         }
         [TestMethod]
-        public void Divide_UInt16_To_UInt32()
+        public void Divide_Int64_To_Single()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
             var ret = left / right;
             
             for (int i = 0; i < ret.size; i++)
@@ -835,10 +613,10 @@ public void Divide_UInt16_To_UInt32()
             }
         }
         [TestMethod]
-        public void Divide_UInt16_To_Int64()
+        public void Divide_Double_To_Boolean()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
             var ret = left / right;
             
             for (int i = 0; i < ret.size; i++)
@@ -849,10 +627,10 @@ public void Divide_UInt16_To_Int64()
             }
         }
         [TestMethod]
-        public void Divide_UInt16_To_UInt64()
+        public void Divide_Double_To_Byte()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
             var ret = left / right;
             
             for (int i = 0; i < ret.size; i++)
@@ -863,10 +641,10 @@ public void Divide_UInt16_To_UInt64()
             }
         }
         [TestMethod]
-        public void Divide_UInt16_To_Double()
+        public void Divide_Double_To_Int32()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
             var ret = left / right;
             
             for (int i = 0; i < ret.size; i++)
@@ -877,10 +655,10 @@ public void Divide_UInt16_To_Double()
             }
         }
         [TestMethod]
-        public void Divide_UInt16_To_Single()
+        public void Divide_Double_To_Int64()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
             var ret = left / right;
             
             for (int i = 0; i < ret.size; i++)
@@ -891,10 +669,10 @@ public void Divide_UInt16_To_Single()
             }
         }
         [TestMethod]
-        public void Divide_UInt16_To_Decimal()
+        public void Divide_Double_To_Single()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
             var ret = left / right;
             
             for (int i = 0; i < ret.size; i++)
@@ -905,9 +683,9 @@ public void Divide_UInt16_To_Decimal()
             }
         }
         [TestMethod]
-        public void Divide_Int32_To_Boolean()
+        public void Divide_Single_To_Boolean()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Single) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
             var ret = left / right;
             
@@ -919,9 +697,9 @@ public void Divide_Int32_To_Boolean()
             }
         }
         [TestMethod]
-        public void Divide_Int32_To_Byte()
+        public void Divide_Single_To_Byte()
         {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
+            var left = np.ones(new Shape(5, 5), NPTypeCode.Single) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
             var ret = left / right;
             
@@ -933,782 +711,12 @@ public void Divide_Int32_To_Byte()
             }
         }
         [TestMethod]
-        public void Divide_Int32_To_Int16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int32_To_UInt16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int32_To_UInt32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int32_To_Int64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int32_To_UInt64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int32_To_Double()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int32_To_Single()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int32_To_Decimal()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt32_To_Boolean()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt32_To_Byte()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt32_To_Int16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt32_To_UInt16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt32_To_Int32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt32_To_Int64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt32_To_UInt64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt32_To_Double()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt32_To_Single()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt32_To_Decimal()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int64_To_Boolean()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int64_To_Byte()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int64_To_Int16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int64_To_UInt16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int64_To_Int32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int64_To_UInt32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int64_To_UInt64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int64_To_Double()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int64_To_Single()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Int64_To_Decimal()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt64_To_Boolean()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt64_To_Byte()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt64_To_Int16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt64_To_UInt16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt64_To_Int32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt64_To_UInt32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt64_To_Int64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt64_To_Double()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt64_To_Single()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_UInt64_To_Decimal()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Double_To_Boolean()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Double_To_Byte()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Double_To_Int16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Double_To_UInt16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Double_To_Int32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Double_To_UInt32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Double_To_Int64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Double_To_UInt64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Double_To_Single()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Double_To_Decimal()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Single_To_Boolean()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Single_To_Byte()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Single_To_Int16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Single_To_UInt16()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Single_To_Int32()
+        public void Divide_Single_To_Int32()
         {
             var left = np.ones(new Shape(5, 5), NPTypeCode.Single) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
             var ret = left / right;
             
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Single_To_UInt32()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Single_To_Int64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
-            var ret = left / right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Divide_Single_To_UInt64()
-        {
-            var left = np.ones(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left / right;
-            
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
diff --git a/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_mod_tests.cs b/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_mod_tests.cs
index 1b9d55604..4fc04bed3 100644
--- a/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_mod_tests.cs
+++ b/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_mod_tests.cs
@@ -18,16 +18,12 @@ public class np_mod_tests
         %foreach a
         [DataRow(NPTypeCode.Boolean, NPTypeCode.#1)]
 #else
+        [DataRow(NPTypeCode.Boolean, NPTypeCode.Boolean)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Byte)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Int16)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt16)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int32)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt32)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Single)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Decimal)]
+        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
 #endif
         [DataTestMethod]
         public void ModAllPossabilitiesBoolean(NPTypeCode ltc, NPTypeCode rtc)
@@ -156,8 +152,8 @@ public void Mod_LeftScalar_Rising()
         #endregion
 
 #if _REGEN
-        %a = ["Boolean","Byte","Int16","UInt16","Int32","UInt32","Int64","UInt64","Double","Single","Decimal"]
-        %b = [true,"1","1","1","1","1u","1L","1UL","1d","1f","1m"]
+        %a = ["Boolean","Byte","Int32","Int64","Double","Single"]
+        %b = [true,"1","1","1L","1d","1f"]
         %mod = "%"
         %foreach forevery(a,a,true), forevery(b,b,true)%
         [TestMethod]
@@ -193,34 +189,6 @@ public void Mod_Boolean_To_Byte()
             }
         }
         [TestMethod]
-        public void Mod_Boolean_To_Int16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Boolean);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Boolean_To_UInt16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Boolean);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Mod_Boolean_To_Int32()
         {
             var left = np.full(4, new Shape(5, 5), NPTypeCode.Boolean);
@@ -235,20 +203,6 @@ public void Mod_Boolean_To_Int32()
             }
         }
         [TestMethod]
-        public void Mod_Boolean_To_UInt32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Boolean);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Mod_Boolean_To_Int64()
         {
             var left = np.full(4, new Shape(5, 5), NPTypeCode.Boolean);
@@ -263,20 +217,6 @@ public void Mod_Boolean_To_Int64()
             }
         }
         [TestMethod]
-        public void Mod_Boolean_To_UInt64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Boolean);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Mod_Boolean_To_Double()
         {
             var left = np.full(4, new Shape(5, 5), NPTypeCode.Boolean);
@@ -305,20 +245,6 @@ public void Mod_Boolean_To_Single()
             }
         }
         [TestMethod]
-        public void Mod_Boolean_To_Decimal()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Boolean);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Mod_Byte_To_Boolean()
         {
             var left = np.full(4, new Shape(5, 5), NPTypeCode.Byte);
@@ -333,34 +259,6 @@ public void Mod_Byte_To_Boolean()
             }
         }
         [TestMethod]
-        public void Mod_Byte_To_Int16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Byte);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Byte_To_UInt16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Byte);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Mod_Byte_To_Int32()
         {
             var left = np.full(4, new Shape(5, 5), NPTypeCode.Byte);
@@ -375,20 +273,6 @@ public void Mod_Byte_To_Int32()
             }
         }
         [TestMethod]
-        public void Mod_Byte_To_UInt32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Byte);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Mod_Byte_To_Int64()
         {
             var left = np.full(4, new Shape(5, 5), NPTypeCode.Byte);
@@ -403,20 +287,6 @@ public void Mod_Byte_To_Int64()
             }
         }
         [TestMethod]
-        public void Mod_Byte_To_UInt64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Byte);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Mod_Byte_To_Double()
         {
             var left = np.full(4, new Shape(5, 5), NPTypeCode.Byte);
@@ -445,23 +315,9 @@ public void Mod_Byte_To_Single()
             }
         }
         [TestMethod]
-        public void Mod_Byte_To_Decimal()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Byte);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int16_To_Boolean()
+        public void Mod_Int32_To_Boolean()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
             var right = np.full(3, new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left % right;
 
@@ -473,9 +329,9 @@ public void Mod_Int16_To_Boolean()
             }
         }
         [TestMethod]
-        public void Mod_Int16_To_Byte()
+        public void Mod_Int32_To_Byte()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
             var right = np.full(3, new Shape(5, 5), NPTypeCode.Byte);
             var ret = left % right;
 
@@ -487,51 +343,9 @@ public void Mod_Int16_To_Byte()
             }
         }
         [TestMethod]
-        public void Mod_Int16_To_UInt16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int16_To_Int32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int16_To_UInt32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int16_To_Int64()
+        public void Mod_Int32_To_Int64()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
             var right = np.full(3, new Shape(5, 5), NPTypeCode.Int64);
             var ret = left % right;
 
@@ -543,23 +357,9 @@ public void Mod_Int16_To_Int64()
             }
         }
         [TestMethod]
-        public void Mod_Int16_To_UInt64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int16_To_Double()
+        public void Mod_Int32_To_Double()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
             var right = np.full(3, new Shape(5, 5), NPTypeCode.Double);
             var ret = left % right;
 
@@ -571,9 +371,9 @@ public void Mod_Int16_To_Double()
             }
         }
         [TestMethod]
-        public void Mod_Int16_To_Single()
+        public void Mod_Int32_To_Single()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
             var right = np.full(3, new Shape(5, 5), NPTypeCode.Single);
             var ret = left % right;
 
@@ -585,23 +385,9 @@ public void Mod_Int16_To_Single()
             }
         }
         [TestMethod]
-        public void Mod_Int16_To_Decimal()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt16_To_Boolean()
+        public void Mod_Int64_To_Boolean()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt16);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
             var right = np.full(3, new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left % right;
 
@@ -613,9 +399,9 @@ public void Mod_UInt16_To_Boolean()
             }
         }
         [TestMethod]
-        public void Mod_UInt16_To_Byte()
+        public void Mod_Int64_To_Byte()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt16);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
             var right = np.full(3, new Shape(5, 5), NPTypeCode.Byte);
             var ret = left % right;
 
@@ -627,10 +413,10 @@ public void Mod_UInt16_To_Byte()
             }
         }
         [TestMethod]
-        public void Mod_UInt16_To_Int16()
+        public void Mod_Int64_To_Int32()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
+            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int32);
             var ret = left % right;
 
             for (int i = 0; i < ret.size; i++)
@@ -641,107 +427,107 @@ public void Mod_UInt16_To_Int16()
             }
         }
         [TestMethod]
-        public void Mod_UInt16_To_Int32()
+        public void Mod_Int64_To_Double()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int32);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
+            var right = np.full(3, new Shape(5, 5), NPTypeCode.Double);
             var ret = left % right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
+                val.Should().Be(1d);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Mod_UInt16_To_UInt32()
+        public void Mod_Int64_To_Single()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt32);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
+            var right = np.full(3, new Shape(5, 5), NPTypeCode.Single);
             var ret = left % right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be(1u);
+                val.Should().Be(1f);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Mod_UInt16_To_Int64()
+        public void Mod_Double_To_Boolean()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int64);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
+            var right = np.full(3, new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left % right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be(1L);
+                val.Should().Be(0);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Mod_UInt16_To_UInt64()
+        public void Mod_Double_To_Byte()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt64);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
+            var right = np.full(3, new Shape(5, 5), NPTypeCode.Byte);
             var ret = left % right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be(1UL);
+                val.Should().Be(1);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Mod_UInt16_To_Double()
+        public void Mod_Double_To_Int32()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Double);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
+            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int32);
             var ret = left % right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be(1d);
+                val.Should().Be(1);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Mod_UInt16_To_Single()
+        public void Mod_Double_To_Int64()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Single);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
+            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int64);
             var ret = left % right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be(1f);
+                val.Should().Be(1L);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Mod_UInt16_To_Decimal()
+        public void Mod_Double_To_Single()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt16);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Decimal);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
+            var right = np.full(3, new Shape(5, 5), NPTypeCode.Single);
             var ret = left % right;
 
             for (int i = 0; i < ret.size; i++)
             {
                 var val = ret.GetAtIndex(i);
-                val.Should().Be(1m);
+                val.Should().Be(1f);
                 Console.WriteLine(val);
             }
         }
         [TestMethod]
-        public void Mod_Int32_To_Boolean()
+        public void Mod_Single_To_Boolean()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
             var right = np.full(3, new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left % right;
 
@@ -753,9 +539,9 @@ public void Mod_Int32_To_Boolean()
             }
         }
         [TestMethod]
-        public void Mod_Int32_To_Byte()
+        public void Mod_Single_To_Byte()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
             var right = np.full(3, new Shape(5, 5), NPTypeCode.Byte);
             var ret = left % right;
 
@@ -767,24 +553,10 @@ public void Mod_Int32_To_Byte()
             }
         }
         [TestMethod]
-        public void Mod_Int32_To_Int16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int32_To_UInt16()
+        public void Mod_Single_To_Int32()
         {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt16);
+            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
+            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int32);
             var ret = left % right;
 
             for (int i = 0; i < ret.size; i++)
@@ -794,762 +566,6 @@ public void Mod_Int32_To_UInt16()
                 Console.WriteLine(val);
             }
         }
-        [TestMethod]
-        public void Mod_Int32_To_UInt32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int32_To_Int64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1L);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int32_To_UInt64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int32_To_Double()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Double);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1d);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int32_To_Single()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Single);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1f);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int32_To_Decimal()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt32_To_Boolean()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(0);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt32_To_Byte()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt32_To_Int16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt32_To_UInt16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt32_To_Int32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt32_To_Int64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1L);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt32_To_UInt64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt32_To_Double()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Double);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1d);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt32_To_Single()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Single);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1f);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt32_To_Decimal()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt32);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int64_To_Boolean()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(0);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int64_To_Byte()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int64_To_Int16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int64_To_UInt16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int64_To_Int32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int64_To_UInt32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int64_To_UInt64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int64_To_Double()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Double);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1d);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int64_To_Single()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Single);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1f);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Int64_To_Decimal()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Int64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt64_To_Boolean()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(0);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt64_To_Byte()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt64_To_Int16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt64_To_UInt16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt64_To_Int32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt64_To_UInt32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt64_To_Int64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1L);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt64_To_Double()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Double);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1d);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt64_To_Single()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Single);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1f);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_UInt64_To_Decimal()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.UInt64);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Double_To_Boolean()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(0);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Double_To_Byte()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Double_To_Int16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Double_To_UInt16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Double_To_Int32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Double_To_UInt32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Double_To_Int64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1L);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Double_To_UInt64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1UL);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Double_To_Single()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Single);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1f);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Double_To_Decimal()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Double);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1m);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Single_To_Boolean()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(0);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Single_To_Byte()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Single_To_Int16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Single_To_UInt16()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Single_To_Int32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Single_To_UInt32()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1u);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Single_To_Int64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1L);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Mod_Single_To_UInt64()
-        {
-            var left = np.full(4, new Shape(5, 5), NPTypeCode.Single);
-            var right = np.full(3, new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left % right;
-
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                val.Should().Be(1UL);
-                Console.WriteLine(val);
-            }
-        }
 #endif
     }
 }
diff --git a/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_multiply_tests.cs b/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_multiply_tests.cs
index f422b9037..606c01d4d 100644
--- a/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_multiply_tests.cs
+++ b/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_multiply_tests.cs
@@ -30,16 +30,10 @@ public void Multiply()
 #else
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Boolean)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Byte)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Int16)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt16)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int32)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt32)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Char)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Single)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Decimal)]
+        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
 #endif
         [DataTestMethod]
         public void MultiplyAllPossabilitiesBoolean(NPTypeCode ltc, NPTypeCode rtc)
@@ -252,8 +246,8 @@ public void Multiply_LeftScalar_Rising()
 
 
 #if _REGEN
-        %a = ["Boolean","Byte","Int16","UInt16","Int32","UInt32","Int64","UInt64","Double","Single","Decimal"]
-        %b = [true,"1","1","1","1","1u","1L","1UL","1d","1f","1m"]
+        %a = ["Boolean","Byte","Int32","Int64","Double","Single"]
+        %b = [true,"1",,"1","1L","1d","1f"]
         %foreach forevery(a,a,true), forevery(b,b,true)%
         [TestMethod]
         public void Multiply_#1_To_#2()
@@ -287,34 +281,6 @@ public void Multiply_Boolean_To_Byte()
             }
         }
         [TestMethod]
-        public void Multiply_Boolean_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Boolean_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Multiply_Boolean_To_Int32()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
@@ -329,20 +295,6 @@ public void Multiply_Boolean_To_Int32()
             }
         }
         [TestMethod]
-        public void Multiply_Boolean_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Multiply_Boolean_To_Int64()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
@@ -357,20 +309,6 @@ public void Multiply_Boolean_To_Int64()
             }
         }
         [TestMethod]
-        public void Multiply_Boolean_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Multiply_Boolean_To_Double()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
@@ -399,20 +337,6 @@ public void Multiply_Boolean_To_Single()
             }
         }
         [TestMethod]
-        public void Multiply_Boolean_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Multiply_Byte_To_Boolean()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -427,34 +351,6 @@ public void Multiply_Byte_To_Boolean()
             }
         }
         [TestMethod]
-        public void Multiply_Byte_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Byte_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Multiply_Byte_To_Int32()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -469,20 +365,6 @@ public void Multiply_Byte_To_Int32()
             }
         }
         [TestMethod]
-        public void Multiply_Byte_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Multiply_Byte_To_Int64()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -497,20 +379,6 @@ public void Multiply_Byte_To_Int64()
             }
         }
         [TestMethod]
-        public void Multiply_Byte_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Multiply_Byte_To_Double()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -539,23 +407,9 @@ public void Multiply_Byte_To_Single()
             }
         }
         [TestMethod]
-        public void Multiply_Byte_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int16_To_Boolean()
+        public void Multiply_Int32_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
             var ret = left * right;
             
@@ -567,9 +421,9 @@ public void Multiply_Int16_To_Boolean()
             }
         }
         [TestMethod]
-        public void Multiply_Int16_To_Byte()
+        public void Multiply_Int32_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
             var ret = left * right;
             
@@ -581,51 +435,9 @@ public void Multiply_Int16_To_Byte()
             }
         }
         [TestMethod]
-        public void Multiply_Int16_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int16_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int16_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int16_To_Int64()
+        public void Multiply_Int32_To_Int64()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
             var ret = left * right;
             
@@ -637,23 +449,9 @@ public void Multiply_Int16_To_Int64()
             }
         }
         [TestMethod]
-        public void Multiply_Int16_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int16_To_Double()
+        public void Multiply_Int32_To_Double()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
             var ret = left * right;
             
@@ -665,9 +463,9 @@ public void Multiply_Int16_To_Double()
             }
         }
         [TestMethod]
-        public void Multiply_Int16_To_Single()
+        public void Multiply_Int32_To_Single()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
             var ret = left * right;
             
@@ -679,23 +477,9 @@ public void Multiply_Int16_To_Single()
             }
         }
         [TestMethod]
-        public void Multiply_Int16_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt16_To_Boolean()
+        public void Multiply_Int64_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
             var ret = left * right;
             
@@ -707,9 +491,9 @@ public void Multiply_UInt16_To_Boolean()
             }
         }
         [TestMethod]
-        public void Multiply_UInt16_To_Byte()
+        public void Multiply_Int64_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
             var ret = left * right;
             
@@ -721,10 +505,10 @@ public void Multiply_UInt16_To_Byte()
             }
         }
         [TestMethod]
-        public void Multiply_UInt16_To_Int16()
+        public void Multiply_Int64_To_Int32()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
@@ -735,10 +519,10 @@ public void Multiply_UInt16_To_Int16()
             }
         }
         [TestMethod]
-        public void Multiply_UInt16_To_Int32()
+        public void Multiply_Int64_To_Double()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
@@ -749,10 +533,10 @@ public void Multiply_UInt16_To_Int32()
             }
         }
         [TestMethod]
-        public void Multiply_UInt16_To_UInt32()
+        public void Multiply_Int64_To_Single()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
@@ -763,10 +547,10 @@ public void Multiply_UInt16_To_UInt32()
             }
         }
         [TestMethod]
-        public void Multiply_UInt16_To_Int64()
+        public void Multiply_Double_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
@@ -777,10 +561,10 @@ public void Multiply_UInt16_To_Int64()
             }
         }
         [TestMethod]
-        public void Multiply_UInt16_To_UInt64()
+        public void Multiply_Double_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
@@ -791,10 +575,10 @@ public void Multiply_UInt16_To_UInt64()
             }
         }
         [TestMethod]
-        public void Multiply_UInt16_To_Double()
+        public void Multiply_Double_To_Int32()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
@@ -805,10 +589,10 @@ public void Multiply_UInt16_To_Double()
             }
         }
         [TestMethod]
-        public void Multiply_UInt16_To_Single()
+        public void Multiply_Double_To_Int64()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
@@ -819,10 +603,10 @@ public void Multiply_UInt16_To_Single()
             }
         }
         [TestMethod]
-        public void Multiply_UInt16_To_Decimal()
+        public void Multiply_Double_To_Single()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
@@ -833,9 +617,9 @@ public void Multiply_UInt16_To_Decimal()
             }
         }
         [TestMethod]
-        public void Multiply_Int32_To_Boolean()
+        public void Multiply_Single_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
             var ret = left * right;
             
@@ -847,9 +631,9 @@ public void Multiply_Int32_To_Boolean()
             }
         }
         [TestMethod]
-        public void Multiply_Int32_To_Byte()
+        public void Multiply_Single_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
             var ret = left * right;
             
@@ -861,24 +645,10 @@ public void Multiply_Int32_To_Byte()
             }
         }
         [TestMethod]
-        public void Multiply_Int32_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int32_To_UInt16()
+        public void Multiply_Single_To_Int32()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
@@ -889,10 +659,10 @@ public void Multiply_Int32_To_UInt16()
             }
         }
         [TestMethod]
-        public void Multiply_Int32_To_UInt32()
+        public void Multiply_Single_To_Int64()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
@@ -903,738 +673,10 @@ public void Multiply_Int32_To_UInt32()
             }
         }
         [TestMethod]
-        public void Multiply_Int32_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int32_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int32_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int32_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int32_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt32_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt32_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt32_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt32_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt32_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt32_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt32_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt32_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt32_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt32_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int64_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int64_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int64_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int64_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int64_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int64_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int64_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int64_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int64_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Int64_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt64_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt64_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt64_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt64_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt64_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt64_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt64_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt64_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt64_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_UInt64_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Double_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Double_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Double_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Double_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Double_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Double_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Double_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Double_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Double_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Double_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Single_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Single_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Single_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Single_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Single_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Single_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Single_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64) + 1;
-            var ret = left * right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(6);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Multiply_Single_To_UInt64()
+        public void Multiply_Single_To_Double()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64) + 1;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Double) + 1;
             var ret = left * right;
             
             for (int i = 0; i < ret.size; i++)
diff --git a/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_subtract_tests.cs b/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_subtract_tests.cs
index 7d71bbd72..86baf7cbe 100644
--- a/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_subtract_tests.cs
+++ b/test/NumSharp.UnitTest/Backends/Unmanaged/Math/np_subtract_tests.cs
@@ -30,16 +30,10 @@ public void Subtract()
 #else
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Boolean)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Byte)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Int16)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt16)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int32)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt32)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Int64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.UInt64)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Char)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
         [DataRow(NPTypeCode.Boolean, NPTypeCode.Single)]
-        [DataRow(NPTypeCode.Boolean, NPTypeCode.Decimal)]
+        [DataRow(NPTypeCode.Boolean, NPTypeCode.Double)]
 #endif
         [DataTestMethod]
         public void SubtractAllPossabilitiesBoolean(NPTypeCode ltc, NPTypeCode rtc)
@@ -255,8 +249,8 @@ public void Subtract_LeftScalar_Rising()
 
 
 #if _REGEN
-        %a = ["Boolean","Byte","Int16","UInt16","Int32","UInt32","Int64","UInt64","Double","Single","Decimal"]
-        %b = [true,"1","1","1","1","1u","1L","1UL","1d","1f","1m"]
+        %a = ["Boolean","Byte","Int32","Int64","Double","Single"]
+        %b = [true,"1","1","1u","1L","1d","1f"]
         %foreach forevery(a,a,true), forevery(b,b,true)%
         [TestMethod]
         public void Subtract_#1_To_#2()
@@ -290,34 +284,6 @@ public void Subtract_Boolean_To_Byte()
             }
         }
         [TestMethod]
-        public void Subtract_Boolean_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Boolean_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Subtract_Boolean_To_Int32()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
@@ -332,20 +298,6 @@ public void Subtract_Boolean_To_Int32()
             }
         }
         [TestMethod]
-        public void Subtract_Boolean_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Subtract_Boolean_To_Int64()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
@@ -360,20 +312,6 @@ public void Subtract_Boolean_To_Int64()
             }
         }
         [TestMethod]
-        public void Subtract_Boolean_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Subtract_Boolean_To_Double()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
@@ -402,20 +340,6 @@ public void Subtract_Boolean_To_Single()
             }
         }
         [TestMethod]
-        public void Subtract_Boolean_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Boolean) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Subtract_Byte_To_Boolean()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -430,34 +354,6 @@ public void Subtract_Byte_To_Boolean()
             }
         }
         [TestMethod]
-        public void Subtract_Byte_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Byte_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Subtract_Byte_To_Int32()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -472,20 +368,6 @@ public void Subtract_Byte_To_Int32()
             }
         }
         [TestMethod]
-        public void Subtract_Byte_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Subtract_Byte_To_Int64()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -500,20 +382,6 @@ public void Subtract_Byte_To_Int64()
             }
         }
         [TestMethod]
-        public void Subtract_Byte_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
         public void Subtract_Byte_To_Double()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
@@ -542,23 +410,9 @@ public void Subtract_Byte_To_Single()
             }
         }
         [TestMethod]
-        public void Subtract_Byte_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Byte) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int16_To_Boolean()
+        public void Subtract_Int32_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left - right;
             
@@ -570,9 +424,9 @@ public void Subtract_Int16_To_Boolean()
             }
         }
         [TestMethod]
-        public void Subtract_Int16_To_Byte()
+        public void Subtract_Int32_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
             var ret = left - right;
             
@@ -584,51 +438,9 @@ public void Subtract_Int16_To_Byte()
             }
         }
         [TestMethod]
-        public void Subtract_Int16_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int16_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int16_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int16_To_Int64()
+        public void Subtract_Int32_To_Int64()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
             var ret = left - right;
             
@@ -640,23 +452,9 @@ public void Subtract_Int16_To_Int64()
             }
         }
         [TestMethod]
-        public void Subtract_Int16_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int16_To_Double()
+        public void Subtract_Int32_To_Double()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
             var ret = left - right;
             
@@ -668,9 +466,9 @@ public void Subtract_Int16_To_Double()
             }
         }
         [TestMethod]
-        public void Subtract_Int16_To_Single()
+        public void Subtract_Int32_To_Single()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
             var ret = left - right;
             
@@ -682,23 +480,9 @@ public void Subtract_Int16_To_Single()
             }
         }
         [TestMethod]
-        public void Subtract_Int16_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt16_To_Boolean()
+        public void Subtract_Int64_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left - right;
             
@@ -710,9 +494,9 @@ public void Subtract_UInt16_To_Boolean()
             }
         }
         [TestMethod]
-        public void Subtract_UInt16_To_Byte()
+        public void Subtract_Int64_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
             var ret = left - right;
             
@@ -724,10 +508,10 @@ public void Subtract_UInt16_To_Byte()
             }
         }
         [TestMethod]
-        public void Subtract_UInt16_To_Int16()
+        public void Subtract_Int64_To_Int32()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
@@ -738,10 +522,10 @@ public void Subtract_UInt16_To_Int16()
             }
         }
         [TestMethod]
-        public void Subtract_UInt16_To_Int32()
+        public void Subtract_Int64_To_Double()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
@@ -752,10 +536,10 @@ public void Subtract_UInt16_To_Int32()
             }
         }
         [TestMethod]
-        public void Subtract_UInt16_To_UInt32()
+        public void Subtract_Int64_To_Single()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
@@ -766,10 +550,10 @@ public void Subtract_UInt16_To_UInt32()
             }
         }
         [TestMethod]
-        public void Subtract_UInt16_To_Int64()
+        public void Subtract_Double_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
@@ -780,10 +564,10 @@ public void Subtract_UInt16_To_Int64()
             }
         }
         [TestMethod]
-        public void Subtract_UInt16_To_UInt64()
+        public void Subtract_Double_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
@@ -794,10 +578,10 @@ public void Subtract_UInt16_To_UInt64()
             }
         }
         [TestMethod]
-        public void Subtract_UInt16_To_Double()
+        public void Subtract_Double_To_Int32()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
@@ -808,10 +592,10 @@ public void Subtract_UInt16_To_Double()
             }
         }
         [TestMethod]
-        public void Subtract_UInt16_To_Single()
+        public void Subtract_Double_To_Int64()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
@@ -822,10 +606,10 @@ public void Subtract_UInt16_To_Single()
             }
         }
         [TestMethod]
-        public void Subtract_UInt16_To_Decimal()
+        public void Subtract_Double_To_Single()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt16) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
@@ -836,9 +620,9 @@ public void Subtract_UInt16_To_Decimal()
             }
         }
         [TestMethod]
-        public void Subtract_Int32_To_Boolean()
+        public void Subtract_Single_To_Boolean()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
             var ret = left - right;
             
@@ -850,9 +634,9 @@ public void Subtract_Int32_To_Boolean()
             }
         }
         [TestMethod]
-        public void Subtract_Int32_To_Byte()
+        public void Subtract_Single_To_Byte()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
             var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
             var ret = left - right;
             
@@ -864,24 +648,10 @@ public void Subtract_Int32_To_Byte()
             }
         }
         [TestMethod]
-        public void Subtract_Int32_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int32_To_UInt16()
+        public void Subtract_Single_To_Int32()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
@@ -892,10 +662,10 @@ public void Subtract_Int32_To_UInt16()
             }
         }
         [TestMethod]
-        public void Subtract_Int32_To_UInt32()
+        public void Subtract_Single_To_Int64()
         {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
+            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
@@ -906,738 +676,10 @@ public void Subtract_Int32_To_UInt32()
             }
         }
         [TestMethod]
-        public void Subtract_Int32_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int32_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int32_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int32_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int32_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt32_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt32_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt32_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt32_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt32_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt32_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt32_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt32_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt32_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt32_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt32) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int64_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int64_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int64_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int64_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int64_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int64_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int64_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int64_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int64_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Int64_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Int64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt64_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt64_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt64_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt64_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt64_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt64_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt64_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt64_To_Double()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt64_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_UInt64_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.UInt64) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Double_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Double_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Double_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Double_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Double_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Double_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Double_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Double_To_UInt64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Double_To_Single()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Single);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Double_To_Decimal()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Double) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Decimal);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Single_To_Boolean()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Boolean);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Single_To_Byte()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Byte);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Single_To_Int16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Single_To_UInt16()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt16);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Single_To_Int32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Single_To_UInt32()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt32);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Single_To_Int64()
-        {
-            var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.Int64);
-            var ret = left - right;
-            
-            for (int i = 0; i < ret.size; i++)
-            {
-                var val = ret.GetAtIndex(i);
-                Convert.ToInt32(val).Should().Be(2);
-                Console.WriteLine(val);
-            }
-        }
-        [TestMethod]
-        public void Subtract_Single_To_UInt64()
+        public void Subtract_Single_To_Double()
         {
             var left = np.zeros(new Shape(5, 5), NPTypeCode.Single) + 3;
-            var right = np.ones(new Shape(5, 5), NPTypeCode.UInt64);
+            var right = np.ones(new Shape(5, 5), NPTypeCode.Double);
             var ret = left - right;
             
             for (int i = 0; i < ret.size; i++)
diff --git a/test/NumSharp.UnitTest/Math/NDArray.Multiply.Test.cs b/test/NumSharp.UnitTest/Math/NDArray.Multiply.Test.cs
index fcb3ef08d..5242b2fae 100644
--- a/test/NumSharp.UnitTest/Math/NDArray.Multiply.Test.cs
+++ b/test/NumSharp.UnitTest/Math/NDArray.Multiply.Test.cs
@@ -11,18 +11,18 @@ namespace NumSharp.UnitTest
     public class MultiplyTest : TestClass
     {
         [TestMethod]
-        public void UInt8MultiplyTest1()
+        public void Int32MultiplyTest1()
         {
-            var nd1 = np.arange(3).astype(np.uint8);
+            var nd1 = np.arange(3);
 
             var nd2 = nd1 * 2;
 
             AssertAreEqual(new int[] {0, 2, 4}, nd2.Data<int>());
         }
         [TestMethod]
-        public void UInt16MultiplyTest1()
+        public void Int32MultiplyTest2()
         {
-            var nd1 = np.arange(3).astype(np.uint16);
+            var nd1 = np.arange(3);
 
             var nd2 = nd1 * 2;
 
diff --git a/test/NumSharp.UnitTest/Operations/NDArray.GRATER.Test.cs b/test/NumSharp.UnitTest/Operations/NDArray.GRATER.Test.cs
new file mode 100644
index 000000000..c311e3a34
--- /dev/null
+++ b/test/NumSharp.UnitTest/Operations/NDArray.GRATER.Test.cs
@@ -0,0 +1,45 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Numerics;
+using System.Collections.Generic;
+using System.Text;
+using System.Linq;
+using NumSharp;
+using NumSharp.Generic;
+
+namespace NumSharp.UnitTest.Operations
+{
+    [TestClass]
+    public class NDArrayGreaterOrLessTest
+    {
+        [TestMethod]
+        public void BoolTwoScalar_NDArray()
+        {
+            NDArray np1 = 1;
+            NDArray np2 = 2;
+            bool np3 = np1 > np2;
+            Assert.IsTrue(!np3);
+
+            np1 = 3;
+            np2 = 2;
+            np3 = np1 > np2;
+            Assert.IsTrue(np3);
+
+            np3 = np2 < np1;
+            Assert.IsTrue(np3);
+        }
+
+        [TestMethod]
+        public void BoolTwo1D_NDArray()
+        {
+            var np1 = new NDArray(new[] { 1, 2, 3, 4 }, new Shape(4));
+            var np2 = new NDArray(new[] { 4, 3, 2, 1 }, new Shape(4));
+
+            var np3 = np1 > np2;
+            Assert.IsTrue(Enumerable.SequenceEqual(new[] { false, false, true, true }, np3.Data<bool>()));
+
+            np3 = np2 < np1;
+            Assert.IsTrue(Enumerable.SequenceEqual(new[] { false, false, true, true }, np3.Data<bool>()));
+        }
+    }
+}
diff --git a/test/NumSharp.UnitTest/Selection/NDArray.Indexing.Test.cs b/test/NumSharp.UnitTest/Selection/NDArray.Indexing.Test.cs
index 0bf415794..de6a66159 100644
--- a/test/NumSharp.UnitTest/Selection/NDArray.Indexing.Test.cs
+++ b/test/NumSharp.UnitTest/Selection/NDArray.Indexing.Test.cs
@@ -74,6 +74,24 @@ public void MaskSetter()
             nd.Should().BeOfValues(-2, 2, -2, 4, -2, 6);
         }
 
+        [TestMethod]
+        public void MaskSetter2D()
+        {
+            var nd = np.arange(15).reshape(5, 3);
+            var mask = new NDArray(new bool[] { true, false, true, false, true }).MakeGeneric<bool>();
+            nd[mask] = 99;
+            nd.Should().BeOfValues(99, 99, 99, 3, 4, 5, 99, 99, 99, 9, 10, 11, 99, 99, 99);
+        }
+
+        [Ignore("to do fix")]
+        [TestMethod]
+        public void MaskSetter3D()
+        {
+            var nd = np.arange(30).reshape(2, 3, 5);
+            var mask = new NDArray(new bool[] { true, true, false, false, true, true }).reshape(2, 3).MakeGeneric<bool>();
+            nd[mask] = 99;
+        }
+
         [TestMethod]
         public void Compare()
         {